gonic | music streaming server / subsonic server API implementation | Audio Utils library

If you try to do ajax request from different location then the request request location then the request will be blocked by Content Security Policy (CSP) which help to detect and mitigate certain types of attacks. You can read more about CSP here.

For fetch to work you have to go to the same location and make fetch request from that location in your case it is http://localhost:8080/.

Note: Since you have defined the root route to return json when you open the location in browser which may raise a GET request and the response json will be returned in browser.

Better answer: as suggested by @Oliver Dain, use zap.AtomicLevel. See their answer for details.

Another option is to create a core with a custom LevelEnabler function. You can use zap.LevelEnablerFunc to convert a closure to a zapcore.LevelEnabler.

The relevant docs:

LevelEnabler decides whether a given logging level is enabled when logging a message.

LevelEnablerFunc is a convenient way to implement zapcore.LevelEnabler with an anonymous function.

That function may then return true or false based on some other variable that changes at runtime:

You need to add WorkingDirectory to your system file

Is maintaining an interface for stream_chat.Client the correct way to go?

If you have a non-interface dependency and you wish to unit test handlers with that, then yes. You need to wrap stream_chat.Client in an interface.

If the third-party struct has a lot of methods, you could split the interface in logical units and inject in each handler only those that are actually needed. The underlying stream_chat.Client implements all of them, but the individual mocks can be kept small and easier to reason about. Personally, I don't think it's worth the overhead. There's plenty of open-source mock generators, above all mock and mockgen, and also tools that generate interfaces from structs.

Is there a way to properly decouple the gin.HandlerFunc, i.e. func(c *gin.Context) from the creation of stream_chat.Client?

You have several options, which you can find here: How to pass arguments to router handlers in Golang using Gin web framework?

In short, the options I prefer are due to better unit-testability are:

1. make the handlers methods of a struct and your dependencies fields of this struct.
2. use a provider pattern and set the provider into the Gin context in a middleware

Set the key on the context: c.Set("id", uuid)

your code have no bug. it works. maybe your network setting is wrong.

I download your code and test it with a local backend server. It works.

backend server code

Solution to the first issue:
when using testify/suite, There are bunch of methods if created for the Suite struct, they will be automatically executed when running the test. That being said, These methods will pass through an interface filter. In the case of .SetupSuite, it has to have NO arguments and No return, in order to run.

Solution to the second issue: There is a way in go-sqlmock to match any kind of data by using sqlmock.AnyArg().

Fixed code:

tl;dr The Keys field is what backs up Gin's Context implementation of context.Context interface as a request-scoped key/value carrier.

I think the Context.Keys is not populated by query params.

Correct. Context.Keys is unrelated to query params. Query params are available with Context.Query.

About Keys instead, the document on the struct field reads:

Keys is a key/value pair exclusively for the context of each request.

And these key/value pairs are accessible with Get and Set. The docs of this latter one are:

Set is used to store a new key/value pair exclusively for this context. It also lazy initializes c.Keys if it was not used previously.

Hence the field is similar to context package's Context.WithValue and Context.Value, e.g. request-scoped parameters. Gin's Context Keys is the exported map that stores the raw key/value pairs. The methods such as GetBool are convenience, in that you don't have to type-assert the interface{} values yourself.

Unlike other web frameworks, Gin's Context does not wrap a context.Context value (except for c.Request.Context), instead it directly implements the interface. This includes the Value method itself, which also accesses the underlying Keys field.

By the way, an important difference from the standard lib context implementation is that context.Context accepts interface{} keys, whereas Gin's Context accepts only string keys.

ADD ./src . - that copies the contents of src to the current folder, stripping away the src part.

It should just be COPY . ./

Also note that it's not recommended to have a src subfolder in your source tree - the folder that contains go.mod is already the source tree.