From 3fa6d5a33b46b86975929a6eda96d097b1bc470d Mon Sep 17 00:00:00 2001 From: Sebastiaan van Stijn Date: Sat, 29 Apr 2023 17:08:47 +0200 Subject: [PATCH] remove dot-imports for gopkg.in/check.v1 Dot-imports were only used in a couple of places, and replacing them makes it more explicit what's imported. Signed-off-by: Sebastiaan van Stijn --- configuration/configuration_test.go | 122 +++++++++--------- configuration/parser_test.go | 16 +-- registry/storage/driver/azure/azure_test.go | 4 +- .../storage/driver/filesystem/driver_test.go | 4 +- .../middleware/redirect/middleware_test.go | 2 +- 5 files changed, 74 insertions(+), 74 deletions(-) diff --git a/configuration/configuration_test.go b/configuration/configuration_test.go index 38319f3d..6f8f021c 100644 --- a/configuration/configuration_test.go +++ b/configuration/configuration_test.go @@ -9,12 +9,12 @@ import ( "testing" "time" - . "gopkg.in/check.v1" + "gopkg.in/check.v1" "gopkg.in/yaml.v2" ) // Hook up gocheck into the "go test" runner -func Test(t *testing.T) { TestingT(t) } +func Test(t *testing.T) { check.TestingT(t) } // configStruct is a canonical example configuration, which should map to configYamlV0_1 var configStruct = Configuration{ @@ -204,51 +204,51 @@ type ConfigSuite struct { expectedConfig *Configuration } -var _ = Suite(new(ConfigSuite)) +var _ = check.Suite(new(ConfigSuite)) -func (suite *ConfigSuite) SetUpTest(c *C) { +func (suite *ConfigSuite) SetUpTest(c *check.C) { os.Clearenv() suite.expectedConfig = copyConfig(configStruct) } // TestMarshalRoundtrip validates that configStruct can be marshaled and // unmarshaled without changing any parameters -func (suite *ConfigSuite) TestMarshalRoundtrip(c *C) { +func (suite *ConfigSuite) TestMarshalRoundtrip(c *check.C) { configBytes, err := yaml.Marshal(suite.expectedConfig) - c.Assert(err, IsNil) + c.Assert(err, check.IsNil) config, err := Parse(bytes.NewReader(configBytes)) c.Log(string(configBytes)) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseSimple validates that configYamlV0_1 can be parsed into a struct // matching configStruct -func (suite *ConfigSuite) TestParseSimple(c *C) { +func (suite *ConfigSuite) TestParseSimple(c *check.C) { config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseInmemory validates that configuration yaml with storage provided as // a string can be parsed into a Configuration struct with no storage parameters -func (suite *ConfigSuite) TestParseInmemory(c *C) { +func (suite *ConfigSuite) TestParseInmemory(c *check.C) { suite.expectedConfig.Storage = Storage{"inmemory": Parameters{}} suite.expectedConfig.Reporting = Reporting{} suite.expectedConfig.Log.Fields = nil config, err := Parse(bytes.NewReader([]byte(inmemoryConfigYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseIncomplete validates that an incomplete yaml configuration cannot // be parsed without providing environment variables to fill in the missing // components. -func (suite *ConfigSuite) TestParseIncomplete(c *C) { +func (suite *ConfigSuite) TestParseIncomplete(c *check.C) { incompleteConfigYaml := "version: 0.1" _, err := Parse(bytes.NewReader([]byte(incompleteConfigYaml))) - c.Assert(err, NotNil) + c.Assert(err, check.NotNil) suite.expectedConfig.Log.Fields = nil suite.expectedConfig.Storage = Storage{"filesystem": Parameters{"rootdirectory": "/tmp/testroot"}} @@ -265,28 +265,28 @@ func (suite *ConfigSuite) TestParseIncomplete(c *C) { os.Setenv("REGISTRY_AUTH_SILLY_REALM", "silly") config, err := Parse(bytes.NewReader([]byte(incompleteConfigYaml))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseWithSameEnvStorage validates that providing environment variables // that match the given storage type will only include environment-defined // parameters and remove yaml-defined parameters -func (suite *ConfigSuite) TestParseWithSameEnvStorage(c *C) { +func (suite *ConfigSuite) TestParseWithSameEnvStorage(c *check.C) { suite.expectedConfig.Storage = Storage{"somedriver": Parameters{"region": "us-east-1"}} os.Setenv("REGISTRY_STORAGE", "somedriver") os.Setenv("REGISTRY_STORAGE_SOMEDRIVER_REGION", "us-east-1") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseWithDifferentEnvStorageParams validates that providing environment variables that change // and add to the given storage parameters will change and add parameters to the parsed // Configuration struct -func (suite *ConfigSuite) TestParseWithDifferentEnvStorageParams(c *C) { +func (suite *ConfigSuite) TestParseWithDifferentEnvStorageParams(c *check.C) { suite.expectedConfig.Storage.setParameter("string1", "us-west-1") suite.expectedConfig.Storage.setParameter("bool1", true) suite.expectedConfig.Storage.setParameter("newparam", "some Value") @@ -296,26 +296,26 @@ func (suite *ConfigSuite) TestParseWithDifferentEnvStorageParams(c *C) { os.Setenv("REGISTRY_STORAGE_SOMEDRIVER_NEWPARAM", "some Value") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseWithDifferentEnvStorageType validates that providing an environment variable that // changes the storage type will be reflected in the parsed Configuration struct -func (suite *ConfigSuite) TestParseWithDifferentEnvStorageType(c *C) { +func (suite *ConfigSuite) TestParseWithDifferentEnvStorageType(c *check.C) { suite.expectedConfig.Storage = Storage{"inmemory": Parameters{}} os.Setenv("REGISTRY_STORAGE", "inmemory") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseWithDifferentEnvStorageTypeAndParams validates that providing an environment variable // that changes the storage type will be reflected in the parsed Configuration struct and that // environment storage parameters will also be included -func (suite *ConfigSuite) TestParseWithDifferentEnvStorageTypeAndParams(c *C) { +func (suite *ConfigSuite) TestParseWithDifferentEnvStorageTypeAndParams(c *check.C) { suite.expectedConfig.Storage = Storage{"filesystem": Parameters{}} suite.expectedConfig.Storage.setParameter("rootdirectory", "/tmp/testroot") @@ -323,48 +323,48 @@ func (suite *ConfigSuite) TestParseWithDifferentEnvStorageTypeAndParams(c *C) { os.Setenv("REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY", "/tmp/testroot") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseWithSameEnvLoglevel validates that providing an environment variable defining the log // level to the same as the one provided in the yaml will not change the parsed Configuration struct -func (suite *ConfigSuite) TestParseWithSameEnvLoglevel(c *C) { +func (suite *ConfigSuite) TestParseWithSameEnvLoglevel(c *check.C) { os.Setenv("REGISTRY_LOGLEVEL", "info") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseWithDifferentEnvLoglevel validates that providing an environment variable defining the // log level will override the value provided in the yaml document -func (suite *ConfigSuite) TestParseWithDifferentEnvLoglevel(c *C) { +func (suite *ConfigSuite) TestParseWithDifferentEnvLoglevel(c *check.C) { suite.expectedConfig.Log.Level = "error" os.Setenv("REGISTRY_LOG_LEVEL", "error") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseInvalidLoglevel validates that the parser will fail to parse a // configuration if the loglevel is malformed -func (suite *ConfigSuite) TestParseInvalidLoglevel(c *C) { +func (suite *ConfigSuite) TestParseInvalidLoglevel(c *check.C) { invalidConfigYaml := "version: 0.1\nloglevel: derp\nstorage: inmemory" _, err := Parse(bytes.NewReader([]byte(invalidConfigYaml))) - c.Assert(err, NotNil) + c.Assert(err, check.NotNil) os.Setenv("REGISTRY_LOGLEVEL", "derp") _, err = Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, NotNil) + c.Assert(err, check.NotNil) } // TestParseWithDifferentEnvReporting validates that environment variables // properly override reporting parameters -func (suite *ConfigSuite) TestParseWithDifferentEnvReporting(c *C) { +func (suite *ConfigSuite) TestParseWithDifferentEnvReporting(c *check.C) { suite.expectedConfig.Reporting.Bugsnag.APIKey = "anotherBugsnagApiKey" suite.expectedConfig.Reporting.Bugsnag.Endpoint = "localhost:8080" suite.expectedConfig.Reporting.NewRelic.LicenseKey = "NewRelicLicenseKey" @@ -376,23 +376,23 @@ func (suite *ConfigSuite) TestParseWithDifferentEnvReporting(c *C) { os.Setenv("REGISTRY_REPORTING_NEWRELIC_NAME", "some NewRelic NAME") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseInvalidVersion validates that the parser will fail to parse a newer configuration // version than the CurrentVersion -func (suite *ConfigSuite) TestParseInvalidVersion(c *C) { +func (suite *ConfigSuite) TestParseInvalidVersion(c *check.C) { suite.expectedConfig.Version = MajorMinorVersion(CurrentVersion.Major(), CurrentVersion.Minor()+1) configBytes, err := yaml.Marshal(suite.expectedConfig) - c.Assert(err, IsNil) + c.Assert(err, check.IsNil) _, err = Parse(bytes.NewReader(configBytes)) - c.Assert(err, NotNil) + c.Assert(err, check.NotNil) } // TestParseExtraneousVars validates that environment variables referring to // nonexistent variables don't cause side effects. -func (suite *ConfigSuite) TestParseExtraneousVars(c *C) { +func (suite *ConfigSuite) TestParseExtraneousVars(c *check.C) { suite.expectedConfig.Reporting.Bugsnag.Endpoint = "localhost:8080" // A valid environment variable @@ -405,13 +405,13 @@ func (suite *ConfigSuite) TestParseExtraneousVars(c *C) { os.Setenv("REGISTRY_REPORTING_ASDF", "ghjk") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseEnvVarImplicitMaps validates that environment variables can set // values in maps that don't already exist. -func (suite *ConfigSuite) TestParseEnvVarImplicitMaps(c *C) { +func (suite *ConfigSuite) TestParseEnvVarImplicitMaps(c *check.C) { readonly := make(map[string]interface{}) readonly["enabled"] = true @@ -423,41 +423,41 @@ func (suite *ConfigSuite) TestParseEnvVarImplicitMaps(c *C) { os.Setenv("REGISTRY_STORAGE_MAINTENANCE_READONLY_ENABLED", "true") config, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, suite.expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, suite.expectedConfig) } // TestParseEnvWrongTypeMap validates that incorrectly attempting to unmarshal a // string over existing map fails. -func (suite *ConfigSuite) TestParseEnvWrongTypeMap(c *C) { +func (suite *ConfigSuite) TestParseEnvWrongTypeMap(c *check.C) { os.Setenv("REGISTRY_STORAGE_SOMEDRIVER", "somestring") _, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, NotNil) + c.Assert(err, check.NotNil) } // TestParseEnvWrongTypeStruct validates that incorrectly attempting to // unmarshal a string into a struct fails. -func (suite *ConfigSuite) TestParseEnvWrongTypeStruct(c *C) { +func (suite *ConfigSuite) TestParseEnvWrongTypeStruct(c *check.C) { os.Setenv("REGISTRY_STORAGE_LOG", "somestring") _, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, NotNil) + c.Assert(err, check.NotNil) } // TestParseEnvWrongTypeSlice validates that incorrectly attempting to // unmarshal a string into a slice fails. -func (suite *ConfigSuite) TestParseEnvWrongTypeSlice(c *C) { +func (suite *ConfigSuite) TestParseEnvWrongTypeSlice(c *check.C) { os.Setenv("REGISTRY_LOG_HOOKS", "somestring") _, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, NotNil) + c.Assert(err, check.NotNil) } // TestParseEnvMany tests several environment variable overrides. // The result is not checked - the goal of this test is to detect panics // from misuse of reflection. -func (suite *ConfigSuite) TestParseEnvMany(c *C) { +func (suite *ConfigSuite) TestParseEnvMany(c *check.C) { os.Setenv("REGISTRY_VERSION", "0.1") os.Setenv("REGISTRY_LOG_LEVEL", "debug") os.Setenv("REGISTRY_LOG_FORMATTER", "json") @@ -471,10 +471,10 @@ func (suite *ConfigSuite) TestParseEnvMany(c *C) { os.Setenv("REGISTRY_AUTH_PARAMS_VALUE2", "value2") _, err := Parse(bytes.NewReader([]byte(configYamlV0_1))) - c.Assert(err, IsNil) + c.Assert(err, check.IsNil) } -func checkStructs(c *C, t reflect.Type, structsChecked map[string]struct{}) { +func checkStructs(c *check.C, t reflect.Type, structsChecked map[string]struct{}) { for t.Kind() == reflect.Ptr || t.Kind() == reflect.Map || t.Kind() == reflect.Slice { t = t.Elem() } @@ -510,7 +510,7 @@ func checkStructs(c *C, t reflect.Type, structsChecked map[string]struct{}) { // TestValidateConfigStruct makes sure that the config struct has no members // with yaml tags that would be ambiguous to the environment variable parser. -func (suite *ConfigSuite) TestValidateConfigStruct(c *C) { +func (suite *ConfigSuite) TestValidateConfigStruct(c *check.C) { structsChecked := make(map[string]struct{}) checkStructs(c, reflect.TypeOf(Configuration{}), structsChecked) } diff --git a/configuration/parser_test.go b/configuration/parser_test.go index 344b2ee4..7f352483 100644 --- a/configuration/parser_test.go +++ b/configuration/parser_test.go @@ -4,7 +4,7 @@ import ( "os" "reflect" - . "gopkg.in/check.v1" + "gopkg.in/check.v1" ) type localConfiguration struct { @@ -25,9 +25,9 @@ var expectedConfig = localConfiguration{ type ParserSuite struct{} -var _ = Suite(new(ParserSuite)) +var _ = check.Suite(new(ParserSuite)) -func (suite *ParserSuite) TestParserOverwriteIninitializedPoiner(c *C) { +func (suite *ParserSuite) TestParserOverwriteIninitializedPoiner(c *check.C) { config := localConfiguration{} os.Setenv("REGISTRY_LOG_FORMATTER", "json") @@ -44,11 +44,11 @@ func (suite *ParserSuite) TestParserOverwriteIninitializedPoiner(c *C) { }) err := p.Parse([]byte(`{version: "0.1", log: {formatter: "text"}}`), &config) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, expectedConfig) } -func (suite *ParserSuite) TestParseOverwriteUnininitializedPoiner(c *C) { +func (suite *ParserSuite) TestParseOverwriteUnininitializedPoiner(c *check.C) { config := localConfiguration{} os.Setenv("REGISTRY_LOG_FORMATTER", "json") @@ -65,6 +65,6 @@ func (suite *ParserSuite) TestParseOverwriteUnininitializedPoiner(c *C) { }) err := p.Parse([]byte(`{version: "0.1"}`), &config) - c.Assert(err, IsNil) - c.Assert(config, DeepEquals, expectedConfig) + c.Assert(err, check.IsNil) + c.Assert(config, check.DeepEquals, expectedConfig) } diff --git a/registry/storage/driver/azure/azure_test.go b/registry/storage/driver/azure/azure_test.go index 89842e81..5b0b9533 100644 --- a/registry/storage/driver/azure/azure_test.go +++ b/registry/storage/driver/azure/azure_test.go @@ -8,7 +8,7 @@ import ( storagedriver "github.com/distribution/distribution/v3/registry/storage/driver" "github.com/distribution/distribution/v3/registry/storage/driver/testsuites" - . "gopkg.in/check.v1" + "gopkg.in/check.v1" ) const ( @@ -20,7 +20,7 @@ const ( ) // Hook up gocheck into the "go test" runner. -func Test(t *testing.T) { TestingT(t) } +func Test(t *testing.T) { check.TestingT(t) } func init() { var ( diff --git a/registry/storage/driver/filesystem/driver_test.go b/registry/storage/driver/filesystem/driver_test.go index 3f56f168..f492d342 100644 --- a/registry/storage/driver/filesystem/driver_test.go +++ b/registry/storage/driver/filesystem/driver_test.go @@ -7,11 +7,11 @@ import ( storagedriver "github.com/distribution/distribution/v3/registry/storage/driver" "github.com/distribution/distribution/v3/registry/storage/driver/testsuites" - . "gopkg.in/check.v1" + "gopkg.in/check.v1" ) // Hook up gocheck into the "go test" runner. -func Test(t *testing.T) { TestingT(t) } +func Test(t *testing.T) { check.TestingT(t) } func init() { root, err := os.MkdirTemp("", "driver-") diff --git a/registry/storage/driver/middleware/redirect/middleware_test.go b/registry/storage/driver/middleware/redirect/middleware_test.go index 36f08c28..afa7bafa 100644 --- a/registry/storage/driver/middleware/redirect/middleware_test.go +++ b/registry/storage/driver/middleware/redirect/middleware_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - check "gopkg.in/check.v1" + "gopkg.in/check.v1" ) func Test(t *testing.T) { check.TestingT(t) }