11 )

12

13 func Test_doWebHookExecutionBitbucket(t *testing.T) {

14 log.SetLogger(t)

15 s, cancel := setupTestHookService(t)

16 defer cancel()

17 task := &sdk.TaskExecution{

18 UUID: sdk.RandomString(10),

19 Type: TypeRepoManagerWebHook,

20 WebHook: &sdk.WebHookExecution{

36 }

37

38 func Test_doWebHookExecutionBitbucketPRReviewerUpdated(t *testing.T) {

39 log.SetLogger(t)

40 s, cancel := setupTestHookService(t)

24 // Test ResyncCommitStatus with a notification where all is disabled.

25 // Must: no error returned, only list status is called

26 func TestResyncCommitStatusNotifDisabled(t *testing.T) {

27 db, cache := test.SetupPG(t)

28

29 ctx := context.TODO()

30

31 pkey := sdk.RandomString(10)

32 proj := assets.InsertTestProject(t, db, cache, pkey, pkey)

33 vcsServer := sdk.ProjectVCSServerLink{

41 // Create Application

42 app := sdk.Application{

43 Name: sdk.RandomString(10),

44 ProjectID: proj.ID,

45 RepositoryFullname: "foo/myrepo",

14 )

15

16 func TestAccAzureRMStorageContainer_basic(t *testing.T) {

17 data := acceptance.BuildTestData(t, "azurerm_storage_container", "test")

18

33 }

34

35 func TestAccAzureRMStorageContainer_deleteAndRecreate(t *testing.T) {

36 data := acceptance.BuildTestData(t, "azurerm_storage_container", "test")

37

62 }

63

64 func TestAccAzureRMStorageContainer_basicAzureADAuth(t *testing.T) {

65 data := acceptance.BuildTestData(t, "azurerm_storage_container", "test")

66

14 )

15

16 func TestAccAzureRMPolicyRemediation_atSubscription(t *testing.T) {

17 data := acceptance.BuildTestData(t, "azurerm_policy_remediation", "test")

18

35 }

36

37 func TestAccAzureRMPolicyRemediation_atSubscriptionWithDefinitionSet(t *testing.T) {

38 data := acceptance.BuildTestData(t, "azurerm_policy_remediation", "test")

39

57 }

58

59 func TestAccAzureRMPolicyRemediation_atResourceGroup(t *testing.T) {

60 data := acceptance.BuildTestData(t, "azurerm_policy_remediation", "test")

61

74 }

75

76 func TestAccAzureRMKustoCluster_withTags(t *testing.T) {

77 data := acceptance.BuildTestData(t, "azurerm_kusto_cluster", "test")

78

315 }

316 }

317 `, data.RandomInteger, data.Locations.Primary, data.RandomString)

318 }

319

642 }

643 }

644 `, data.RandomInteger, data.Locations.Primary, data.RandomString, data.RandomString, data.RandomString, data.RandomString, data.RandomString, data.RandomString)

645 }

646

9 )

10

11 func TestAccAzureRMHDInsightStormCluster_basic(t *testing.T) {

12 data := acceptance.BuildTestData(t, "azurerm_hdinsight_storm_cluster", "test")

13 resource.ParallelTest(t, resource.TestCase{

35 }

36

37 func TestAccAzureRMHDInsightStormCluster_requiresImport(t *testing.T) {

38 data := acceptance.BuildTestData(t, "azurerm_hdinsight_storm_cluster", "test")

39

56 }

57

58 func TestAccAzureRMHDInsightStormCluster_update(t *testing.T) {

59 data := acceptance.BuildTestData(t, "azurerm_hdinsight_storm_cluster", "test")

60 resource.ParallelTest(t, resource.TestCase{

19 // port with a random name. An error will be returned if the listener could not

20 // be created.

21 func CreateListener(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer) (*listeners.Listener, error) {

22 listenerName := tools.RandomString("TESTACCT-", 8)

23 listenerDescription := tools.RandomString("TESTACCT-DESC-", 8)

24 listenerPort := tools.RandomInt(1, 100)

25

56 // CreateLoadBalancer will create a load balancer with a random name on a given

57 // subnet. An error will be returned if the loadbalancer could not be created.

58 func CreateLoadBalancer(t *testing.T, client *gophercloud.ServiceClient, subnetID string) (*loadbalancers.LoadBalancer, error) {

59 lbName := tools.RandomString("TESTACCT-", 8)

60 lbDescription := tools.RandomString("TESTACCT-DESC-", 8)

61

62 t.Logf("Attempting to create loadbalancer %s on subnet %s", lbName, subnetID)

23 // CreateNetwork will create basic network. An error will be returned if the

24 // network could not be created.

25 func CreateNetwork(t *testing.T, client *gophercloud.ServiceClient) (*networks.Network, error) {

26 networkName := tools.RandomString("TESTACC-", 8)

27 networkDescription := tools.RandomString("TESTACC-DESC-", 8)

28 createOpts := networks.CreateOpts{

29 Name: networkName,

49 // CreateNetworkWithoutPortSecurity will create a network without port security.

50 // An error will be returned if the network could not be created.

51 func CreateNetworkWithoutPortSecurity(t *testing.T, client *gophercloud.ServiceClient) (*networks.Network, error) {

52 networkName := tools.RandomString("TESTACC-", 8)

78 // CreatePort will create a port on the specified subnet. An error will be

79 // returned if the port could not be created.

80 func CreatePort(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID string) (*ports.Port, error) {

81 portName := tools.RandomString("TESTACC-", 8)

19 // port with a random name. An error will be returned if the listener could not

20 // be created.

21 func CreateListener(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer) (*listeners.Listener, error) {

22 listenerName := tools.RandomString("TESTACCT-", 8)

23 listenerDescription := tools.RandomString("TESTACCT-DESC-", 8)

24 listenerPort := tools.RandomInt(1, 100)

25

57 // balancer on a random port with a random name. An error will be returned

58 // if the listener could not be created.

59 func CreateListenerHTTP(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer) (*listeners.Listener, error) {

60 listenerName := tools.RandomString("TESTACCT-", 8)

61 listenerDescription := tools.RandomString("TESTACCT-DESC-", 8)

62 listenerPort := tools.RandomInt(1, 100)

63

25 // CreateAsymmetric Order will create a random asymmetric order.

26 // An error will be returned if the order could not be created.

27 func CreateAsymmetricOrder(t *testing.T, client *gophercloud.ServiceClient) (*orders.Order, error) {

28 name := tools.RandomString("TESTACC-", 8)

70 // CreateCertificateContainer will create a random certificate container.

71 // An error will be returned if the container could not be created.

72 func CreateCertificateContainer(t *testing.T, client *gophercloud.ServiceClient, passphrase, private, certificate *secrets.Secret) (*containers.Container, error) {

73 containerName := tools.RandomString("TESTACC-", 8)

121 // CreateKeyOrder will create a random key order.

122 // An error will be returned if the order could not be created.

123 func CreateKeyOrder(t *testing.T, client *gophercloud.ServiceClient) (*orders.Order, error) {

124 name := tools.RandomString("TESTACC-", 8)

163 // CreateRSAContainer will create a random RSA container.

164 // An error will be returned if the container could not be created.

165 func CreateRSAContainer(t *testing.T, client *gophercloud.ServiceClient, passphrase, private, public *secrets.Secret) (*containers.Container, error) {

166 containerName := tools.RandomString("TESTACC-", 8)

18

19 // Given a consumer with two groups, if we invalidate one it should be invalidated and one warning should be set.

20 func TestConsumerInvalidateGroupForUser_InvalidateOneConsumerGroup(t *testing.T) {

21 db, _ := test.SetupPG(t, bootstrap.InitiliazeDB)

22

24

25 u := sdk.AuthentifiedUser{

26 Username: sdk.RandomString(10),

27 }

28 require.NoError(t, user.Insert(context.TODO(), db, &u))

32

33 c := sdk.AuthConsumer{

34 Name: sdk.RandomString(10),

35 Description: sdk.RandomString(10),

57

58 // Given a consumer with two groups, if we invalidate one it should not be invalidated if the user is an admin.

59 func TestConsumerInvalidateGroupForUser_InvalidateOneConsumerGroupForAdmin(t *testing.T) {

60 db, _ := test.SetupPG(t, bootstrap.InitiliazeDB)

61

83 authUser, _ := assets.InsertLambdaUser(t, db, g)

84

85 p := assets.InsertTestProject(t, db, api.Cache, sdk.RandomString(10), sdk.RandomString(10))

86

87 require.NoError(t, group.InsertLinkGroupUser(context.TODO(), db, &group.LinkGroupUser{

379 }

380

381 func Test_checkSessionPermissions(t *testing.T) {

382 api, db, _ := newTestAPI(t)

383

472 api, db, _ := newTestAPI(t)

473

474 g := assets.InsertTestGroup(t, db, sdk.RandomString(10))

475 defer func() {

476 assets.DeleteTestGroup(t, db, g)

17 )

18

19 func TestHandleDialog(t *testing.T) {

20 user := &model.User{

21 Id: model.NewId(),

22 Username: model.NewRandomString(10),

23 }

24 testTime := time.Now().UTC().Round(time.Second).Add(20 * time.Duration(time.Minute))

65 }

66

67 t.Run("view dialog", func(t *testing.T) {

68

69 api := setupAPI()

30 a := Assertions{

31 OutputFormat: OutputFormatFromEnv(),

32 Context: WithContextID(context.Background(), randomString(8)),

33 }

34 for _, opt := range opts {

39

40 // New returns a new instance of `Assertions`.

41 func New(t *testing.T, opts ...Option) *Assertions {

42 a := Assertions{

43 T: t,

44 OutputFormat: OutputFormatFromEnv(),

45 Context: WithContextID(context.Background(), randomString(8)),

46 }

47 if t != nil {

50

51 DDMFormField ddmFormField = createDDMFormField(

52 fieldName, RandomTestUtil.randomString(),

53 DDMFormFieldTypeConstants.DOCUMENT_LIBRARY, "document-library",

54 true, false, true);

25 }

26

27 func Test_NetInterfaceNameValid(t *testing.T) {

28 for _, tt := range ifcNameTests {

29 ret, _ := NetInterfaceNameValid(tt.ifcName)

51 nil},

52 {testLink{name: "ifc03", linkType: "dummy"},

53 LinkOptions{MacAddr: "fa:de:b0:99:52:1c"}, "randomstring",

54 nil},

55 }

56

57 func Test_FindInterfaceByMacAddress(t *testing.T) {

58 for _, tt := range ifcMacTests {

59 tl := &testLink{}

13 )

14

15 func TestBulkProcessorDefaults(t *testing.T) {

16 client := setupTestClientAndCreateIndex(t)

17

40 }

41

42 func TestBulkProcessorCommitOnBulkActions(t *testing.T) {

43 //client := setupTestClientAndCreateIndexAndLog(t, SetTraceLog(log.New(os.Stdout, "", 0)))

44 client := setupTestClientAndCreateIndex(t)

63 }

64

65 func TestBulkProcessorCommitOnBulkSize(t *testing.T) {

66 //client := setupTestClientAndCreateIndexAndLog(t, SetTraceLog(log.New(os.Stdout, "", 0)))

67 client := setupTestClientAndCreateIndex(t)

38 }

39

40 func randomString(length int) string {

41 buf := make([]byte, length)

42 rand.Read(buf)

52 }

53

54 func TestEncDec(t *testing.T) {

55 Convey("Tests encoding and decoding the cookie data", t, func() {

56 key := getSecretKey()

69 }

70

71 func TestHTTPScenario(t *testing.T) {

72 Convey("Given a simple HTTP scenario", t, func() {

73 key := getSecretKey()

20 // port with a random name. An error will be returned if the listener could not

21 // be created.

22 func CreateListener(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer) (*listeners.Listener, error) {

23 listenerName := tools.RandomString("TESTACCT-", 8)

49 // CreateLoadBalancer will create a load balancer with a random name on a given

50 // subnet. An error will be returned if the loadbalancer could not be created.

51 func CreateLoadBalancer(t *testing.T, client *gophercloud.ServiceClient, subnetID string) (*loadbalancers.LoadBalancer, error) {

52 lbName := tools.RandomString("TESTACCT-", 8)

79 // CreateMember will create a member with a random name, port, address, and

80 // weight. An error will be returned if the member could not be created.

81 func CreateMember(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer, pool *pools.Pool, subnetID, subnetCIDR string) (*pools.Member, error) {

82 memberName := tools.RandomString("TESTACCT-", 8)

116 // CreateMonitor will create a monitor with a random name for a specific pool.

117 // An error will be returned if the monitor could not be created.

118 func CreateMonitor(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer, pool *pools.Pool) (*monitors.Monitor, error) {

119 monitorName := tools.RandomString("TESTACCT-", 8)

17 )

18

19 func TestNodes(t *testing.T) {

20 client := setup(t)

21

40 }

41

42 func findServer(t *testing.T) string {

43 var serverIP string

44

73

74 opts := &servers.CreateOpts{

75 Name: tools.RandomString("lb_test_", 5),

76 ImageRef: imageRef,

77 FlavorRef: flavorRef,

7 )

8

9 func TestRandomStringDigits(t *testing.T) {

10 t.Log("TestRandomStringDigits")

27 }

28

29 func TestFirstName(t *testing.T) {

30 t.Log("TestFirstName")

31 firstNameMale := FirstName(Male)

47 }

48

49 func TestLastName(t *testing.T) {

50 t.Log("TestLastName")

51 lastName := LastName()

56 }

57

58 func TestFullName(t *testing.T) {

59 t.Log("TestFullName")

60

21 // has so many options. An error will be returned if the project was

22 // unable to be created.

23 func CreateProject(t *testing.T, client *gophercloud.ServiceClient, c *projects.CreateOpts) (*projects.Project, error) {

24 name := tools.RandomString("ACPTTEST", 8)

25 description := tools.RandomString("ACPTTEST-DESC", 8)

26 t.Logf("Attempting to create project: %s", name)

27

53 // has so many options. An error will be returned if the user was

54 // unable to be created.

55 func CreateUser(t *testing.T, client *gophercloud.ServiceClient, c *users.CreateOpts) (*users.User, error) {

56 name := tools.RandomString("ACPTTEST", 8)

82 // has so many options. An error will be returned if the group was

83 // unable to be created.

84 func CreateGroup(t *testing.T, client *gophercloud.ServiceClient, c *groups.CreateOpts) (*groups.Group, error) {

85 name := tools.RandomString("ACPTTEST", 8)

17 // CreateUploadImage will upload volume it as volume-baked image. An name of new image or err will be

18 // returned

19 func CreateUploadImage(t *testing.T, client *gophercloud.ServiceClient, volume *volumes.Volume) (volumeactions.VolumeImage, error) {

20 if testing.Short() {

21 t.Skip("Skipping test that requires volume-backed image uploading in short mode.")

22 }

23

24 imageName := tools.RandomString("ACPTTEST", 16)

25 uploadImageOpts := volumeactions.UploadImageOpts{

26 ImageName: imageName,

47 // DeleteUploadedImage deletes uploaded image. An error will be returned

48 // if the deletion request failed.

49 func DeleteUploadedImage(t *testing.T, client *gophercloud.ServiceClient, imageName string) error {

50 if testing.Short() {

51 t.Skip("Skipping test that requires volume-backed image removing in short mode.")

25 question := model.NewRandomString(10)

26 answerOptions := []string{model.NewRandomString(10), model.NewRandomString(10), model.NewRandomString(10)}

27 p, err := poll.NewPoll(creator, question, answerOptions, poll.Settings{

28 Anonymous: true,

54 question := model.NewRandomString(10)

55 answerOptions := []string{model.NewRandomString(10), model.NewRandomString(10), model.NewRandomString(10)}

56 p, err := poll.NewPoll(creator, question, answerOptions, poll.Settings{

57 Anonymous: true,

201 }

202

203 func TestAddAnswerOption(t *testing.T) {

204 assert := assert.New(t)

205

217 assert.NotNil(err)

218 })

219 t.Run("dublicant options with spaces", func(t *testing.T) {

220 p := testutils.GetPollWithVotes()

221

33 }

34

35 func TestMarshalUnmarshal(t *testing.T) {

36 rand := rand.New(rand.NewSource(0))

37

81 }

82

83 func TestFuzz(t *testing.T) {

84 rand := rand.New(rand.NewSource(0))

85 for _, iface := range tests {

103 }

104

105 func randomString(n int, rand *rand.Rand) string {

106 b := randomBytes(n, rand)

107 return string(b)

48

49 DDMFormField ddmFormField = createDDMFormField(

50 fieldName, RandomTestUtil.randomString(), "ddm-documentlibrary",

51 "document-library", true, false, true);

52

18 )

19

20 func Test_authMiddleware_WithAuth(t *testing.T) {

21 api, db, _ := newTestAPI(t)

22

38 assert.Equal(t, u.ID, getAPIConsumer(ctx).AuthentifiedUserID)

39

40 req = assets.NewJWTAuthentifiedRequest(t, sdk.RandomString(10), http.MethodGet, "", nil)

41 w = httptest.NewRecorder()

42 ctx, err = api.authMiddleware(context.TODO(), w, req, config)

44 }

45

46 func Test_authMiddleware_WithAuthConsumerDisabled(t *testing.T) {

47 api, db, _ := newTestAPI(t)

48

18 )

19

20 func TestGeneratePublicLinkHash(t *testing.T) {

21 filename1 := model.NewId() + "/" + model.NewRandomString(16) + ".txt"

22 filename2 := model.NewId() + "/" + model.NewRandomString(16) + ".txt"

23 salt1 := model.NewRandomString(32)

24 salt2 := model.NewRandomString(32)

25

26 hash1 := GeneratePublicLinkHash(filename1, salt1)

41 }

42

43 func TestDoUploadFile(t *testing.T) {

44 th := Setup()

45 defer th.TearDown()

15 )

16

17 func TestLBs(t *testing.T) {

18 client := setup(t)

19

42 }

43

44 func createLB(t *testing.T, client *gophercloud.ServiceClient, count int) []int {

45 ids := []int{}

46

47 for i := 0; i < count; i++ {

48 opts := lbs.CreateOpts{

49 Name: tools.RandomString("test_", 5),

50 Port: 80,

51 Protocol: "HTTP",

30 }

31

32 func TestMarshalUnmarshal(t *testing.T) {

33 rand := rand.New(rand.NewSource(0))

34 for i, iface := range tests {

72 }

73

74 func TestFuzz(t *testing.T) {

75 rand := rand.New(rand.NewSource(0))

76 for _, iface := range tests {

94 }

95

96 func randomString(n int, rand *rand.Rand) string {

97 b := randomBytes(n, rand)

98 return string(b)

29 args args

30 wantErr bool

31 setup func(t *testing.T, args args)

32 asserts func(t *testing.T, pip sdk.Pipeline)

33 tearDown func(t *testing.T, args args)

34 }

35

36 func testImportUpdate(t *testing.T, db gorp.SqlExecutor, store cache.Store, tt testcase) {

37 msgChan := make(chan sdk.Message, 1)

38 done := make(chan bool)

75 }

76

77 func TestImportUpdate(t *testing.T) {

78 db, cache := test.SetupPG(t, bootstrap.InitiliazeDB)

79

11 )

12

13 func TestSecGroupsList(t *testing.T) {

14 client, err := clients.NewComputeV2Client()

15 if err != nil {

32 }

33

34 func TestSecGroupsCreate(t *testing.T) {

35 client, err := clients.NewComputeV2Client()

36 if err != nil {

45 }

46

47 func TestSecGroupsUpdate(t *testing.T) {

48 client, err := clients.NewComputeV2Client()

49 if err != nil {

10 )

11

12 func TestGetDomains(t *testing.T) {

13 domain := reqEnv(t, "MG_DOMAIN")

14 apiKey := reqEnv(t, "MG_API_KEY")

24 }

25

26 func TestGetSingleDomain(t *testing.T) {

27 domain := reqEnv(t, "MG_DOMAIN")

28 apiKey := reqEnv(t, "MG_API_KEY")

46 }

47

48 func TestGetSingleDomainNotExist(t *testing.T) {

49 domain := reqEnv(t, "MG_DOMAIN")

50 apiKey := reqEnv(t, "MG_API_KEY")

29 proj := assets.InsertTestProject(t, db, api.Cache, pkey, pkey)

30 app := &sdk.Application{

31 Name: sdk.RandomString(10),

32 }

33 test.NoError(t, application.Insert(db, *proj, app))

172 }

173

174 func Test_postApplicationDeploymentStrategyConfigHandler_InsertTwoDifferentIntegrations(t *testing.T) {

175 api, db, router := newTestAPI(t)

176

298 require.NoError(t, err)

299

300 _, jws, err := builtin.NewConsumer(context.TODO(), db, sdk.RandomString(10), sdk.RandomString(10), localConsumer, u.GetGroupIDs(),

301 sdk.NewAuthConsumerScopeDetails(sdk.AuthConsumerScopeProject))

302

14 // CreateFloatingIP creates a floating IP on a given network and port. An error

15 // will be returned if the creation failed.

16 func CreateFloatingIP(t *testing.T, client *gophercloud.ServiceClient, networkID, portID string) (*floatingips.FloatingIP, error) {

17 t.Logf("Attempting to create floating IP on port: %s", portID)

18

35 // the OS_EXTGW_ID environment variable to be set. An error is returned if the

36 // creation failed.

37 func CreateExternalRouter(t *testing.T, client *gophercloud.ServiceClient) (*routers.Router, error) {

38 var router *routers.Router

39 choices, err := clients.AcceptanceTestChoicesFromEnv()

42 }

43

44 routerName := tools.RandomString("TESTACC-", 8)

45

46 t.Logf("Attempting to create external router: %s", routerName)

36 properties := make(map[string]string)

37 for i := 0; i < 10; i++ {

38 properties[randomString(rand.Intn(20))] = randomString(rand.Intn(20))

39 }

40 return properties

49 }

50

51 func randomString(length int) string {

52 bs := make([]byte, length)

53 for i := 0; i < len(bs); i++ {

63 }

64

65 func Test_encode(t *testing.T) {

66 for i := 0; i < 1000; i++ {

67 rc := randomNewRemotingCommand()

14 )

15

16 func TestInit(t *testing.T) {

17 jenkins = CreateJenkins("http://localhost:8080", "admin", "admin")

18 _, err := jenkins.Init()

20 }

21

22 func TestCreateJobs(t *testing.T) {

23 job1ID := "Job1_test"

24 job2ID := "Job2_test"

37 }

38

39 func TestCreateNodes(t *testing.T) {

40

41 id1 := "node1_test"

13 )

14

15 func TestAccAzureRMDataFactoryDatasetJSON_basic(t *testing.T) {

16 data := acceptance.BuildTestData(t, "azurerm_data_factory_dataset_json", "test")

17

32 }

33

34 func TestAccAzureRMDataFactoryDatasetJSON_update(t *testing.T) {

35 data := acceptance.BuildTestData(t, "azurerm_data_factory_dataset_json", "test")

36

298 }

299

300 func TestAccAzureRMDataFactoryDatasetJSON_blob(t *testing.T) {

301 data := acceptance.BuildTestData(t, "azurerm_data_factory_dataset_json", "test")

302

22 // port with a random name. An error will be returned if the listener could not

23 // be created.

24 func CreateListener(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer) (*listeners.Listener, error) {

25 listenerName := tools.RandomString("TESTACCT-", 8)

26 listenerDescription := tools.RandomString("TESTACCT-DESC-", 8)

27 listenerPort := tools.RandomInt(1, 100)

28

59 // CreateLoadBalancer will create a load balancer with a random name on a given

60 // subnet. An error will be returned if the loadbalancer could not be created.

61 func CreateLoadBalancer(t *testing.T, client *gophercloud.ServiceClient, subnetID string, tags []string) (*loadbalancers.LoadBalancer, error) {

62 lbName := tools.RandomString("TESTACCT-", 8)

63 lbDescription := tools.RandomString("TESTACCT-DESC-", 8)

64

65 t.Logf("Attempting to create loadbalancer %s on subnet %s", lbName, subnetID)

16 // since a fallback route is created by default

17

18 func TestAccAzureRMIotHubFallbackRoute_basic(t *testing.T) {

19 data := acceptance.BuildTestData(t, "azurerm_iothub_fallback_route", "test")

20

35 }

36

37 func TestAccAzureRMIotHubFallbackRoute_update(t *testing.T) {

38 data := acceptance.BuildTestData(t, "azurerm_iothub_fallback_route", "test")

39

185 enabled = true

186 }

187 `, data.RandomInteger, data.Locations.Primary, data.RandomString)

188 }

189

21 )

22

23 func TestFileExistingFile(t *testing.T) {

24 fh := createFile()

25 s, _ := serializers.NewInfluxSerializer()

41 }

42

43 func TestFileNewFile(t *testing.T) {

44 s, _ := serializers.NewInfluxSerializer()

45 fh := tmpFile()

61 }

62

63 func TestFileExistingFiles(t *testing.T) {

64 fh1 := createFile()

65 fh2 := createFile()

12 )

13

14 func TestAccAzureRMKustoDatabase_basic(t *testing.T) {

15 data := acceptance.BuildTestData(t, "azurerm_kusto_database", "test")

16

31 }

32

33 func TestAccAzureRMKustoDatabase_softDeletePeriod(t *testing.T) {

34 data := acceptance.BuildTestData(t, "azurerm_kusto_database", "test")

35

57 }

58

59 func TestAccAzureRMKustoDatabase_hotCachePeriod(t *testing.T) {

60 data := acceptance.BuildTestData(t, "azurerm_kusto_database", "test")

61

15 )

16

17 func TestNodeGroupsCRUD(t *testing.T) {

18 // API not available until Magnum train

19 clients.SkipRelease(t, "stable/mitaka")

40 var nodeGroupID string

41

42 t.Run("list", func(t *testing.T) { testNodeGroupsList(t, client, clusterID) })

43 t.Run("listone-get", func(t *testing.T) { testNodeGroupGet(t, client, clusterID) })

44 t.Run("create", func(t *testing.T) { nodeGroupID = testNodeGroupCreate(t, client, clusterID) })

45

46 t.Logf("Created nodegroup: %s", nodeGroupID)

56 th.AssertNoErr(t, err)

57

58 t.Run("update", func(t *testing.T) { testNodeGroupUpdate(t, client, clusterID, nodeGroupID) })

59 t.Run("delete", func(t *testing.T) { testNodeGroupDelete(t, client, clusterID, nodeGroupID) })

15 // AddUserRole will grant a role to a user in a tenant. An error will be

16 // returned if the grant was unsuccessful.

17 func AddUserRole(t *testing.T, client *gophercloud.ServiceClient, tenant *tenants.Tenant, user *users.User, role *roles.Role) error {

18 t.Logf("Attempting to grant user %s role %s in tenant %s", user.ID, role.ID, tenant.ID)

19

32 // has so many options. An error will be returned if the project was

33 // unable to be created.

34 func CreateTenant(t *testing.T, client *gophercloud.ServiceClient, c *tenants.CreateOpts) (*tenants.Tenant, error) {

35 name := tools.RandomString("ACPTTEST", 8)

58 // CreateUser will create a user with a random name and adds them to the given

59 // tenant. An error will be returned if the user was unable to be created.

60 func CreateUser(t *testing.T, client *gophercloud.ServiceClient, tenant *tenants.Tenant) (*users.User, error) {

61 userName := tools.RandomString("user_", 5)

81 // the tenant ID failed to be deleted. This works best when using it as

82 // a deferred function.

83 func DeleteTenant(t *testing.T, client *gophercloud.ServiceClient, tenantID string) {

84 err := tenants.Delete(client, tenantID).ExtractErr()

85 if err != nil {

30 //}

31

32 func TestRandomString(t *testing.T) {

33 r1 := helpers.RandomString(8)

34 assert.Len(t, r1, 8)

35

36 r2 := helpers.RandomString(8)

37 assert.Len(t, r2, 8)

38

59 }

60

61 func TestFlattenArrayOfStrings(t *testing.T) {

62 assert.Equal(t, "[]", helpers.FlattenArrayOfStrings([]string{}))

63 assert.Equal(t, `["1"]`, helpers.FlattenArrayOfStrings([]string{"1"}))

76 }

77

78 func TestStringToFloat64(t *testing.T) {

79 assert.Equal(t, helpers.StringToFloat64("4.11"), float64(4.11))

80 }

14 )

15

16 func TestAccAzureRMHPCCacheBlobTarget_basic(t *testing.T) {

17 data := acceptance.BuildTestData(t, "azurerm_hpc_cache_blob_target", "test")

18

33 }

34

35 func TestAccAzureRMHPCCacheBlobTarget_update(t *testing.T) {

36 data := acceptance.BuildTestData(t, "azurerm_hpc_cache_blob_target", "test")

37

237 principal_id = data.azuread_service_principal.test.object_id

238 }

239 `, data.RandomInteger, data.Locations.Primary, data.RandomInteger, data.RandomInteger, data.RandomInteger, data.RandomString, data.RandomString)

240 }

241

30 user.Id = 1

31

32 return &user, helpers.RandomString(16)

33 }

34

35 func TestTooLongKey(t *testing.T) {

36 user, _ := makeTestData()

37 key := helpers.RandomString(101)

45 }

46

47 func TestDecimalPoints(t *testing.T) {

48

49 }

15 // CreateExternalNetwork will create an external network. An error will be

16 // returned if the creation failed.

17 func CreateExternalNetwork(t *testing.T, client *gophercloud.ServiceClient) (*networks.Network, error) {

18 networkName := tools.RandomString("TESTACC-", 8)

45 // CreatePortWithSecurityGroup will create a port with a security group

46 // attached. An error will be returned if the port could not be created.

47 func CreatePortWithSecurityGroup(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID, secGroupID string) (*ports.Port, error) {

48 portName := tools.RandomString("TESTACC-", 8)

71 // CreateSecurityGroup will create a security group with a random name.

72 // An error will be returned if one was failed to be created.

73 func CreateSecurityGroup(t *testing.T, client *gophercloud.ServiceClient) (*groups.SecGroup, error) {

74 secGroupName := tools.RandomString("TESTACC-", 8)

93 // and random port between 80 and 99.

94 // An error will be returned if one was failed to be created.

95 func CreateSecurityGroupRule(t *testing.T, client *gophercloud.ServiceClient, secGroupID string) (*rules.SecGroupRule, error) {

96 t.Logf("Attempting to create security group rule in group: %s", secGroupID)

97

13 )

14

15 func TestAccAWSRedshiftSecurityGroup_ingressCidr(t *testing.T) {

16 var v redshift.ClusterSecurityGroup

17 rInt := acctest.RandInt()

40 }

41

42 func TestAccAWSRedshiftSecurityGroup_updateIngressCidr(t *testing.T) {

43 var v redshift.ClusterSecurityGroup

44 rInt := acctest.RandInt()

79 }

80

81 func TestAccAWSRedshiftSecurityGroup_ingressSecurityGroup(t *testing.T) {

82 var v redshift.ClusterSecurityGroup

83 rInt := acctest.RandInt()

12 )

13

14 func TestAccAzureRMStorageShareDirectory_basic(t *testing.T) {

15 data := acceptance.BuildTestData(t, "azurerm_storage_share_directory", "test")

16

31 }

32

33 func TestAccAzureRMStorageShareDirectory_uppercase(t *testing.T) {

34 data := acceptance.BuildTestData(t, "azurerm_storage_share_directory", "test")

35

50 }

51

52 func TestAccAzureRMStorageShareDirectory_requiresImport(t *testing.T) {

53 data := acceptance.BuildTestData(t, "azurerm_storage_share_directory", "test")

54

17 // CreateDatabase will create a database with a randomly generated name.

18 // An error will be returned if the database was unable to be created.

19 func CreateDatabase(t *testing.T, client *gophercloud.ServiceClient, instanceID string) error {

20 name := tools.RandomString("ACPTTEST", 8)

35 // OS_DATASTORE_TYPE_ID environment variable.

36 // An error will be returned if the instance was unable to be created.

37 func CreateInstance(t *testing.T, client *gophercloud.ServiceClient) (*instances.Instance, error) {

38 if testing.Short() {

39 t.Skip("Skipping test that requires instance creation in short mode.")

45 }

46

47 name := tools.RandomString("ACPTTEST", 8)

48 t.Logf("Attempting to create instance: %s", name)

49

72 // CreateUser will create a user with a randomly generated name.

73 // An error will be returned if the user was unable to be created.

74 func CreateUser(t *testing.T, client *gophercloud.ServiceClient, instanceID string) error {

75 name := tools.RandomString("ACPTTEST", 8)

15 // CreateMember will create a load balancer member in a specified pool on a

16 // random port. An error will be returned if the member could not be created.

17 func CreateMember(t *testing.T, client *gophercloud.ServiceClient, poolID string) (*members.Member, error) {

18 protocolPort := tools.RandomInt(100, 1000)

19 address := tools.RandomInt(2, 200)

38 // CreateMonitor will create a monitor with a random name for a specific pool.

39 // An error will be returned if the monitor could not be created.

40 func CreateMonitor(t *testing.T, client *gophercloud.ServiceClient) (*monitors.Monitor, error) {

41 t.Logf("Attempting to create monitor.")

42

61 // CreatePool will create a pool with a random name. An error will be returned

62 // if the pool could not be deleted.

63 func CreatePool(t *testing.T, client *gophercloud.ServiceClient, subnetID string) (*pools.Pool, error) {

64 poolName := tools.RandomString("TESTACCT-", 8)

86 // specified subnet and pool. An error will be returned if the vip could

87 // not be created.

88 func CreateVIP(t *testing.T, client *gophercloud.ServiceClient, subnetID, poolID string) (*vips.VirtualIP, error) {

89 vipName := tools.RandomString("TESTACCT-", 8)

25 }

26

27 func TestEnvLenDup(t *testing.T) {

28 env := &Env{

29 "foo=bar",

83 }

84

85 func TestSetenvInt(t *testing.T) {

86 job := mkJob(t, "dummy")

87

152 res := make([][2]string, l)

153 for i := 0; i < l; i++ {

154 t := [2]string{testutils.RandomString(5), testutils.RandomString(20)}

155 res[i] = t

156 }

9 )

10

11 func TestAuthJson(t *testing.T) {

12 a1 := AuthData{}

13 a1.ClientId = NewId()

34 }

35

36 func TestAuthPreSave(t *testing.T) {

37 a1 := AuthData{}

38 a1.ClientId = NewId()

43 }

44

45 func TestAuthIsValid(t *testing.T) {

46

47 ad := AuthData{}

12 )

13

14 func TestAccAzureRMKustoDatabasePrincipalAssignment_basic(t *testing.T) {

15 data := acceptance.BuildTestData(t, "azurerm_kusto_database_principal_assignment", "test")

16

31 }

32

33 func TestAccAzureRMKustoDatabasePrincipalAssignment_requiresImport(t *testing.T) {

34 data := acceptance.BuildTestData(t, "azurerm_kusto_database_principal_assignment", "test")

35

161 role = "Viewer"

162 }

163 `, data.RandomInteger, data.Locations.Primary, data.RandomString, data.RandomInteger, data.RandomInteger)

164 }

165

10 )

11

12 func TestManager_Get(t *testing.T) {

13 now := time.Now()

14 user := model.User{

83 }

84

85 func TestManager_All(t *testing.T) {

86 //now := time.Now()

87 //user := model.User{

156 }

157

158 //func TestDefaultDataManager_Channels(t *testing.T) {

159 // //suffix := helpers.RandomString(8)

194 //}

195 //

196 //func TestDefaultDataManager_Channel(t *testing.T) {

197 // suffix := helpers.RandomString(8)

14 )

15

16 func TestAccAzureRMUserAssignedIdentity_basic(t *testing.T) {

17 data := acceptance.BuildTestData(t, "azurerm_user_assigned_identity", "test")

18

34 })

35 }

36 func TestAccAzureRMUserAssignedIdentity_requiresImport(t *testing.T) {

37 data := acceptance.BuildTestData(t, "azurerm_user_assigned_identity", "test")

38

132 location = azurerm_resource_group.test.location

133 }

134 `, data.RandomInteger, data.Locations.Primary, data.RandomString)

135 }

136

13 // (which our test suite can't easily workaround)

14

15 func testAccDataSourceAzureRMMonitorLogProfile_storageaccount(t *testing.T) {

16 data := acceptance.BuildTestData(t, "data.azurerm_monitor_log_profile", "test")

17

38 }

39

40 func testAccDataSourceAzureRMMonitorLogProfile_eventhub(t *testing.T) {

41 data := acceptance.BuildTestData(t, "data.azurerm_monitor_log_profile", "test")

42

104 name = azurerm_monitor_log_profile.test.name

105 }

106 `, data.RandomInteger, data.Locations.Primary, data.RandomString, data.RandomInteger, data.Locations.Primary)

107 }

108

12 )

13

14 func TestAccAzureRMKustoAttachedDatabaseConfiguration_basic(t *testing.T) {

15 data := acceptance.BuildTestData(t, "azurerm_kusto_attached_database_configuration", "test")

16

79 database_name = "*"

80 }

81 `, data.RandomInteger, data.Locations.Primary, data.RandomString, data.RandomString, data.RandomInteger, data.RandomInteger)

82 }

83

19 // has so many options. An error will be returned if the project was

20 // unable to be created.

21 func CreateProject(t *testing.T, client *gophercloud.ServiceClient, c *projects.CreateOpts) (*projects.Project, error) {

22 name := tools.RandomString("ACPTTEST", 8)

46 // has so many options. An error will be returned if the user was

47 // unable to be created.

48 func CreateUser(t *testing.T, client *gophercloud.ServiceClient, c *users.CreateOpts) (*users.User, error) {

49 name := tools.RandomString("ACPTTEST", 8)

73 // has so many options. An error will be returned if the group was

74 // unable to be created.

75 func CreateGroup(t *testing.T, client *gophercloud.ServiceClient, c *groups.CreateOpts) (*groups.Group, error) {

76 name := tools.RandomString("ACPTTEST", 8)

100 // has many options. An error will be returned if the domain was

101 // unable to be created.

102 func CreateDomain(t *testing.T, client *gophercloud.ServiceClient, c *domains.CreateOpts) (*domains.Domain, error) {

103 name := tools.RandomString("ACPTTEST", 8)

11 )

12

13 func TestTextGenerator_GenerateDataBySchema_MaxLengthLessThanMinLength_Error(t *testing.T) {

14 textGeneratorInstance := &textGenerator{}

15 schema := openapi3.NewSchema()

24 }

25

26 func TestTextGenerator_GenerateDataBySchema_MaxLengthLessThan5_RandomStringOfGivenLength(t *testing.T) {

27 textGeneratorInstance := &textGenerator{}

28 schema := openapi3.NewSchema()

36 }

37

38 func TestTextGenerator_GenerateDataBySchema_MinAndMaxLength_LengthOfStringInRange(t *testing.T) {

39 randomSource := rand.NewSource(time.Now().UnixNano())

40 textGeneratorInstance := &textGenerator{

14 // CreateNetwork will create basic network. An error will be returned if the

15 // network could not be created.

16 func CreateNetwork(t *testing.T, client *gophercloud.ServiceClient) (*networks.Network, error) {

17 networkName := tools.RandomString("TESTACC-", 8)

34 // CreatePort will create a port on the specified subnet. An error will be

35 // returned if the port could not be created.

36 func CreatePort(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID string) (*ports.Port, error) {

37 portName := tools.RandomString("TESTACC-", 8)

67 // CreatePortWithNoSecurityGroup will create a port with no security group

68 // attached. An error will be returned if the port could not be created.

69 func CreatePortWithNoSecurityGroup(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID string) (*ports.Port, error) {

70 portName := tools.RandomString("TESTACC-", 8)

102 // CreateSubnet will create a subnet on the specified Network ID. An error

103 // will be returned if the subnet could not be created.

104 func CreateSubnet(t *testing.T, client *gophercloud.ServiceClient, networkID string) (*subnets.Subnet, error) {

105 subnetName := tools.RandomString("TESTACC-", 8)

205 }{{

206 name: "no clustername, namespace, or label selector specified should match any MachineSet",

207 testSpec: createTestSpec(RandomString(6), RandomString(6), RandomString(6), 1, false, nil),

208 autoDiscoveryConfig: &clusterAPIAutoDiscoveryConfig{labelSelector: labels.NewSelector()},

209 shouldMatch: true,

210 }, {

211 name: "no clustername, namespace, or label selector specified should match any MachineDeployment",

212 testSpec: createTestSpec(RandomString(6), RandomString(6), RandomString(6), 1, true, nil),

213 autoDiscoveryConfig: &clusterAPIAutoDiscoveryConfig{labelSelector: labels.NewSelector()},

214 shouldMatch: true,

242 }, {

243 name: "clustername specified does not match MachineDeployment, namespace matches, no labels specified",

244 testSpec: createTestSpec(RandomString(6), "foo", RandomString(6), 1, true, nil),

245 autoDiscoveryConfig: &clusterAPIAutoDiscoveryConfig{

246 clusterName: "foo",

28 )

29

30 func TestString(t *testing.T) {

31 valid := "0123456789abcdefghijklmnopqrstuvwxyz"

32 for _, l := range []int{0, 1, 2, 10, 123} {

44

45 // Confirm that panic occurs on invalid input.

46 func TestRangePanic(t *testing.T) {

47 defer func() {

48 if err := recover(); err == nil {

54 }

55

56 func TestIntn(t *testing.T) {

57 // 0 is invalid.

58 for _, max := range []int{1, 2, 10, 123} {

14 )

15

16 func TestSecGroups(t *testing.T) {

17 client, err := newClient()

18 th.AssertNoErr(t, err)

24 listSecGroups(t, client)

25

26 newName := tools.RandomString("secgroup_", 5)

27 updateSecGroup(t, client, groupID, newName)

28

42 }

43

44 func createSecGroup(t *testing.T, client *gophercloud.ServiceClient) string {

45 opts := secgroups.CreateOpts{

46 Name: tools.RandomString("secgroup_", 5),

18 )

19

20 func Test_getConsumersByUserHandler(t *testing.T) {

21 api, db, _ := newTestAPI(t)

22

26 require.NoError(t, err)

27

28 consumer, _, err := builtin.NewConsumer(context.TODO(), db, sdk.RandomString(10), "", localConsumer, nil,

29 sdk.NewAuthConsumerScopeDetails(sdk.AuthConsumerScopeUser))

30 require.NoError(t, err)

60 }

61

62 func Test_postConsumerByUserHandler(t *testing.T) {

63 api, db, _ := newTestAPI(t)

64

25 }

26

27 func TestEnvLenDup(t *testing.T) {

28 env := &Env{

29 "foo=bar",

78 }

79

80 func TestSetenvBool(t *testing.T) {

81 job := mkJob(t, "dummy")

82 job.SetenvBool("foo", true)

164 res := make([][2]string, l)

165 for i := 0; i < l; i++ {

166 t := [2]string{testutils.RandomString(5), testutils.RandomString(20)}

167 res[i] = t

168 }

32 func descriptorPtr(d ispec.Descriptor) *ispec.Descriptor { return &d }

33

34 func randomDescriptor(t *testing.T) ispec.Descriptor {

35 var descriptor ispec.Descriptor

36

45 n := rand.Intn(32)

46 for i := 0; i < n; i++ {

47 descriptor.Annotations[randomString(32)] = randomString(32)

48 }

49

53 // Make sure that an identity mapping doesn't change the struct, and that it

54 // actually does visit all of the descriptors once.

55 func TestMapDescriptors_Identity(t *testing.T) {

56 // List of interfaces to use MapDescriptors on, as well as how many

57 // *unique* descriptors they contain.

12 )

13

14 func TestAccAzureRMMonitorActivityLogAlert_basic(t *testing.T) {

15 data := acceptance.BuildTestData(t, "azurerm_monitor_activity_log_alert", "test")

16

36 }

37

38 func TestAccAzureRMMonitorActivityLogAlert_requiresImport(t *testing.T) {

39 data := acceptance.BuildTestData(t, "azurerm_monitor_activity_log_alert", "test")

40

58 }

59

60 func TestAccAzureRMMonitorActivityLogAlert_singleResource(t *testing.T) {

61 data := acceptance.BuildTestData(t, "azurerm_monitor_activity_log_alert", "test")

62

14 )

15

16 func Test_DAOVariable(t *testing.T) {

17 db, cache := test.SetupPG(t)

18

19 key := sdk.RandomString(10)

20 proj := assets.InsertTestProject(t, db, cache, key, key)

21

61 }

62

63 func Test_DAOVariableAllProjects(t *testing.T) {

64 db, cache := test.SetupPG(t)

65

16 // CreateFirewall will create a Firewaill with a random name and a specified

17 // policy ID. An error will be returned if the firewall could not be created.

18 func CreateFirewall(t *testing.T, client *gophercloud.ServiceClient, policyID string) (*firewalls.Firewall, error) {

19 firewallName := tools.RandomString("TESTACC-", 8)

46 // specified policy ID attached to a specified Router. An error will be

47 // returned if the firewall could not be created.

48 func CreateFirewallOnRouter(t *testing.T, client *gophercloud.ServiceClient, policyID string, routerID string) (*firewalls.Firewall, error) {

49 firewallName := tools.RandomString("TESTACC-", 8)

78 // CreatePolicy will create a Firewall Policy with a random name and given

79 // rule. An error will be returned if the rule could not be created.

80 func CreatePolicy(t *testing.T, client *gophercloud.ServiceClient, ruleID string) (*policies.Policy, error) {

81 policyName := tools.RandomString("TESTACC-", 8)

103 //source port, destination address and port. An error will be returned if

104 // the rule could not be created.

105 func CreateRule(t *testing.T, client *gophercloud.ServiceClient) (*rules.Rule, error) {

106 ruleName := tools.RandomString("TESTACC-", 8)

88 }

89

90 func TestLineReader(t *testing.T) {

91 r := bytes.NewReader([]byte(`

92

321 }

322

323 func TestRandomString(t *testing.T) {

324 var lastR string

325 for x := 0; x < 100; x++ {

387 }

388

389 func TestWriteIndented(t *testing.T) {

390 s := []byte("Hello,\nworld.")

391 s2 := " Hello,\n world."

19 // CreateFloatingIP creates a floating IP on a given network and port. An error

20 // will be returned if the creation failed.

21 func CreateFloatingIP(t *testing.T, client *gophercloud.ServiceClient, networkID, portID string) (*floatingips.FloatingIP, error) {

22 t.Logf("Attempting to create floating IP on port: %s", portID)

23

43 // CreateFloatingIPWithFixedIP creates a floating IP on a given network and port with a

44 // defined fixed IP. An error will be returned if the creation failed.

45 func CreateFloatingIPWithFixedIP(t *testing.T, client *gophercloud.ServiceClient, networkID, portID, fixedIP string) (*floatingips.FloatingIP, error) {

46 t.Logf("Attempting to create floating IP on port: %s and address: %s", portID, fixedIP)

47

69 // CreatePortForwarding creates a port forwarding for a given floating IP

70 // and port. An error will be returned if the creation failed.

71 func CreatePortForwarding(t *testing.T, client *gophercloud.ServiceClient, fipID string, portID string, portFixedIPs []ports.IP) (*portforwarding.PortForwarding, error) {

72 t.Logf("Attempting to create Port forwarding for floating IP with ID: %s", fipID)

73

13 )

14

15 func TestSubnetsList(t *testing.T) {

16 client, err := clients.NewNetworkV2Client()

17 if err != nil {

34 }

35

36 func TestSubnetCRUD(t *testing.T) {

37 client, err := clients.NewNetworkV2Client()

38 if err != nil {

57

58 // Update Subnet

59 newSubnetName := tools.RandomString("TESTACC-", 8)

60 updateOpts := subnets.UpdateOpts{

61 Name: newSubnetName,

13 )

14

15 func TestGenericContainersCRUD(t *testing.T) {

16 clients.SkipRelease(t, "stable/mitaka")

17 clients.SkipRelease(t, "stable/newton")

21 th.AssertNoErr(t, err)

22

23 payload := tools.RandomString("SUPERSECRET-", 8)

24 secret, err := CreateSecretWithPayload(t, client, payload)

25 th.AssertNoErr(t, err)

28 defer DeleteSecret(t, client, secretID)

29

30 payload1 := tools.RandomString("SUPERSECRET-", 8)

31 secret1, err := CreateSecretWithPayload(t, client, payload1)

32 th.AssertNoErr(t, err)

26 import static org.jboss.as.patching.IoUtils.NO_CONTENT;

27 import static org.jboss.as.patching.runner.TestUtils.createModule0;

28 import static org.jboss.as.patching.runner.TestUtils.randomString;

29 import static org.jboss.as.patching.tool.PatchTool.Factory.policyBuilder;

30

65 // Create a conflict

66 final File base = builder.getFile("modules", "system", "layers", "base");

67 createModule0(base, "org.jboss.test", randomString());

68

69 final PatchingTestStepBuilder oneOff1 = builder.createStepBuilder();

28 import static org.jboss.as.patching.Constants.MODULES;

29 import static org.jboss.as.patching.IoUtils.mkdir;

30 import static org.jboss.as.patching.runner.TestUtils.randomString;

31

32 import java.io.File;

60 @Before

61 public void setup() throws Exception {

62 tempDir = mkdir(new File(System.getProperty("java.io.tmpdir")), "patching-" + randomString());

63 File jbossHome = mkdir(tempDir, "jboss-installation");

64 mkdir(jbossHome, MODULES, "system", LAYERS, BASE);

20 package org.xwiki.test.ui;

21

22 import org.apache.commons.lang.RandomStringUtils;

23 import org.junit.Assert;

24 import org.junit.Test;

54 public void testInlineEditCanChangeTitle()

55 {

56 String title = RandomStringUtils.randomAlphanumeric(4);

57 getUtil().gotoPage("EditInlineTest", "testInlineEditCanChangeTitle", "inline", "title=" + title);

58 ViewPage vp = new InlinePage().clickSaveAndView();

73 public void testInlineEditPreservesTitle()

74 {

75 String title = RandomStringUtils.randomAlphanumeric(4);

76 getUtil().gotoPage("EditInlineTest", "testInlineEditPreservesTitle", "save", "title=" + title);

77 ViewPage vp = new ViewPage();

18 )

19

20 func TestEncryptDecrytCredentials(t *testing.T) {

21 encryptedCreds1, err := EncryptCredentials("me@mycozy.cloud", "fzEE6HFWsSp8jP")

22 if !assert.NoError(t, err) {

59 }

60

61 func TestEncryptDecrytUTF8Credentials(t *testing.T) {

62 rng := rand.New(rand.NewSource(time.Now().UnixNano()))

63 for i := 0; i < 1024; i++ {

80

81 for i := 0; i < 1024; i++ {

82 login := utils.RandomString(rng.Intn(256))

83 password := utils.RandomString(rng.Intn(256))

98 }

99

100 func TestDecryptCredentialsRandom(t *testing.T) {

101 rng := rand.New(rand.NewSource(time.Now().UnixNano()))

102 for i := 0; i < 1024; i++ {

16 // CreateVolume will create a volume with a random name and size of 1GB. An

17 // error will be returned if the volume was unable to be created.

18 func CreateVolume(t *testing.T, client *gophercloud.ServiceClient) (*volumes.Volume, error) {

19 if testing.Short() {

20 t.Skip("Skipping test that requires volume creation in short mode.")

21 }

22

23 volumeName := tools.RandomString("ACPTTEST", 16)

24 t.Logf("Attempting to create volume: %s", volumeName)

25

44 // CreateVolumeFromImage will create a volume from with a random name and size of

45 // 1GB. An error will be returned if the volume was unable to be created.

46 func CreateVolumeFromImage(t *testing.T, client *gophercloud.ServiceClient) (*volumes.Volume, error) {

47 if testing.Short() {

48 t.Skip("Skipping test that requires volume creation in short mode.")

16

17 // Subscriptions

18 func TestSubscriptionsWithIncorrectInput(t *testing.T) {

19 client := http.Client{}

20

29 }

30

31 //func TestSubscriptions(t *testing.T) {

32 // client := http.Client{}

33 //

47 //

48 //// Subscribe

49 //func subscribeWithPayload(t *testing.T, payload map[string]interface{}) {

50 // client := http.Client{}

51 // req := test_helper.MakePutRequestWithUserId("/v1/subscription", payload, USER_ID)

15 "Resources": {

16 "string3": {

17 "Type": "ALIYUN::RandomString",

18 "DependsOn": [

19 "string2"

26 "string1": {

27 "Test1": "Hello",

28 "Type": "ALIYUN::RandomString"

29 },

30 "string2": {

31 "Type": "ALIYUN::RandomString",

32 "DependsOn": [

33 "string1"

13 )

14

15 func TestAccAzureRMDedicatedHardwareSecurityModule_basic(t *testing.T) {

16 data := acceptance.BuildTestData(t, "azurerm_dedicated_hardware_security_module", "test")

17

32 }

33

34 func TestAccAzureRMDedicatedHardwareSecurityModule_requiresImport(t *testing.T) {

35 data := acceptance.BuildTestData(t, "azurerm_dedicated_hardware_security_module", "test")

36

51 }

52

53 func TestAccAzureRMDedicatedHardwareSecurityModule_complete(t *testing.T) {

54 data := acceptance.BuildTestData(t, "azurerm_dedicated_hardware_security_module", "test")

55

12 )

13

14 func TestVariablesList(t *testing.T) {

15 client := testClient(t)

16 ctx := context.Background()

27 defer vTestCleanup2()

28

29 t.Run("without list options", func(t *testing.T) {

30 vl, err := client.Variables.List(ctx, wTest.ID, VariableListOptions{})

31 require.NoError(t, err)

38 })

39

40 t.Run("with list options", func(t *testing.T) {

41 t.Skip("paging not supported yet in API")

42 // Request a page number which is out of range. The result should

16 // CreateExternalNetwork will create an external network. An error will be

17 // returned if the creation failed.

18 func CreateExternalNetwork(t *testing.T, client *gophercloud.ServiceClient) (*networks.Network, error) {

19 networkName := tools.RandomString("TESTACC-", 8)

20 networkDescription := tools.RandomString("TESTACC-DESC-", 8)

21

22 t.Logf("Attempting to create external network: %s", networkName)

51 // CreatePortWithSecurityGroup will create a port with a security group

52 // attached. An error will be returned if the port could not be created.

53 func CreatePortWithSecurityGroup(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID, secGroupID string) (*ports.Port, error) {

54 portName := tools.RandomString("TESTACC-", 8)

55 portDescription := tools.RandomString("TESTACC-DESC-", 8)

56 iFalse := false

57

12 // CreateRecordSet will create a RecordSet with a random name. An error will

13 // be returned if the zone was unable to be created.

14 func CreateRecordSet(t *testing.T, client *gophercloud.ServiceClient, zone *zones.Zone) (*recordsets.RecordSet, error) {

15 t.Logf("Attempting to create recordset: %s", zone.Name)

16

44 // CreateZone will create a Zone with a random name. An error will

45 // be returned if the zone was unable to be created.

46 func CreateZone(t *testing.T, client *gophercloud.ServiceClient) (*zones.Zone, error) {

47 zoneName := tools.RandomString("ACPTTEST", 8) + ".com."

78 //

79 // This is only for example purposes as it will try to do a zone transfer.

80 func CreateSecondaryZone(t *testing.T, client *gophercloud.ServiceClient) (*zones.Zone, error) {

81 zoneName := tools.RandomString("ACPTTEST", 8) + ".com."

109 // the record set failed to be deleted. This works best when used as a deferred

110 // function.

111 func DeleteRecordSet(t *testing.T, client *gophercloud.ServiceClient, rs *recordsets.RecordSet) {

112 err := recordsets.Delete(client, rs.ZoneID, rs.ID).ExtractErr()

113 if err != nil {

43 )

44

45 func Test_Operator_InformerProcessing(t *testing.T) {

46 // Arrange

47 name := string(uuid.NewUUID())

51 objects := make([]string, size)

52 for id := range objects {

53 objects[id] = randomString(10)

54 }

55

92 }

93

94 func Test_Operator_MultipleInformers(t *testing.T) {

95 // Arrange

96 name := string(uuid.NewUUID())

21 )

22

23 func TestInsertPipeline(t *testing.T) {

24 db, _ := test.SetupPG(t)

25

26 pk := sdk.RandomString(8)

27

28 p := sdk.Project{

74 }

75

76 func TestInsertPipelineWithParemeters(t *testing.T) {

77 db, _ := test.SetupPG(t)

78

30 RandomInteger int

31

32 // RandomString is a random 5 character string is unique to this test case

33 RandomString string

56

57 // BuildTestData generates some test data for the given resource

58 func BuildTestData(t *testing.T, resourceType string, resourceLabel string) TestData {

59 EnsureProvidersAreInitialised()

60

66 testData := TestData{

67 RandomInteger: tf.AccRandTimeInt(),

68 RandomString: acctest.RandString(5),

69 ResourceName: fmt.Sprintf("%s.%s", resourceType, resourceLabel),

70 Environment: *env,

117 }

118

119 // RandomStringOfLength is a random 1 to 1024 character string which is unique to this test case

120 func (td *TestData) RandomStringOfLength(len int) string {

25 }

26

27 func TestKvdbNewClose(t *testing.T) {

28 dir, err := ioutil.TempDir("", "example")

29 assert.Nil(t, err)

37 }

38

39 func TestKvddbSetGet(t *testing.T) {

40 dir, err := ioutil.TempDir("", "example")

41 assert.Nil(t, err)

84 }

85

86 func TestKvdbMemSet(t *testing.T) {

87 dir, err := ioutil.TempDir("", "example")

88 assert.Nil(t, err)

13 )

14

15 func TestLayer3RouterList(t *testing.T) {

16 client, err := clients.NewNetworkV2Client()

17 if err != nil {

35 }

36

37 func TestLayer3ExternalRouterCreateDelete(t *testing.T) {

38 client, err := clients.NewNetworkV2Client()

39 if err != nil {

49 tools.PrintResource(t, router)

50

51 newName := tools.RandomString("TESTACC-", 8)

52 updateOpts := routers.UpdateOpts{

53 Name: newName,

12 )

13

14 func createLogWriter(t *testing.T) LogWriter {

15 dir := getTempDir(t)

16 logWriter := LogWriter{

21 }

22

23 func TestEnsureDirectoryExistsCreatesDirectory(t *testing.T) {

24 t.Parallel()

25

34 }

35

36 func TestEnsureDirectoryExistsHandlesExistingDirectory(t *testing.T) {

37 t.Parallel()

38

13 )

14

15 func TestAccAzureRMBackupProtectionContainerStorageAccount_basic(t *testing.T) {

16 data := acceptance.BuildTestData(t, "azurerm_backup_container_storage_account", "test")

17

66 storage_account_id = azurerm_storage_account.test.id

67 }

68 `, data.RandomInteger, data.Locations.Primary, data.RandomInteger, data.RandomString)

69 }

70

11 )

12

13 //func TestMe(t *testing.T) {

14 // client := http.Client{}

15 //

32 //}

33

34 func TestLoginByWrongEmail(t *testing.T) {

35 client := http.Client{}

36

48 }

49

50 func TestLoginByEmail(t *testing.T) {

51 client := http.Client{}

52

13 )

14

15 func TestAccAzureRMTableEntity_basic(t *testing.T) {

16 data := acceptance.BuildTestData(t, "azurerm_storage_table_entity", "test")

17

32 }

33

34 func TestAccAzureRMTableEntity_requiresImport(t *testing.T) {

35 data := acceptance.BuildTestData(t, "azurerm_storage_table_entity", "test")

36

54 }

55

56 func TestAccAzureRMTableEntity_update(t *testing.T) {

57 data := acceptance.BuildTestData(t, "azurerm_storage_table_entity", "test")

58

12 )

13

14 func TestPortsList(t *testing.T) {

15 client, err := clients.NewNetworkV2Client()

16 if err != nil {

33 }

34

35 func TestPortsCRUD(t *testing.T) {

36 client, err := clients.NewNetworkV2Client()

37 if err != nil {

67

68 // Update port

69 newPortName := tools.RandomString("TESTACC-", 8)

70 updateOpts := ports.UpdateOpts{

71 Name: newPortName,

16

17 var (

18 adbWalletMgmtDbName = RandomString(1, charsetWithoutDigits) + RandomString(13, charset)

19

20 AutonomousDatabaseInstanceWalletManagementResourceConfig = AutonomousDatabaseInstanceWalletManagementResourceDependencies +

35

36 // issue-routing-tag: database/dbaas-adb

37 func TestDatabaseAutonomousDatabaseInstanceWalletManagementResource_basic(t *testing.T) {

38 httpreplay.SetScenario("TestDatabaseAutonomousDatabaseInstanceWalletManagementResource_basic")

39 defer httpreplay.SaveScenario()

15 )

16

17 func TestAccAzureRMStorageTable_basic(t *testing.T) {

18 data := acceptance.BuildTestData(t, "azurerm_storage_table", "test")

19

34 }

35

36 func TestAccAzureRMStorageTable_requiresImport(t *testing.T) {

37 data := acceptance.BuildTestData(t, "azurerm_storage_table", "test")

38

56 }

57

58 func TestAccAzureRMStorageTable_disappears(t *testing.T) {

59 data := acceptance.BuildTestData(t, "azurerm_storage_table", "test")

60

18 var numObjects = 2

19

20 func TestObjects(t *testing.T) {

21 client, err := clients.NewObjectStorageV1Client()

22 if err != nil {

27 oNames := make([]string, numObjects)

28 for i := 0; i < len(oNames); i++ {

29 oNames[i] = tools.RandomString("test-object-", 8)

30 }

31

32 // Create a container to hold the test objects.

33 cName := tools.RandomString("test-container-", 8)

34 header, err := containers.Create(client, cName, nil).Extract()

35 th.AssertNoErr(t, err)

16 )

17

18 func TestDependenciesLifecycle(t *testing.T) {

19 p := porter.NewTestPorter(t)

20 p.SetupIntegrationTest()

32 }

33

34 func randomString(len int) string {

35 rand.Seed(time.Now().UnixNano())

36 bytes := make([]byte, len)

63 p.CopyDirectory(filepath.Join(p.TestDir, "../build/testdata/bundles/wordpress"), ".", false)

64

65 namespace = randomString(10)

66 installOpts := porter.InstallOptions{}

67 installOpts.CredentialIdentifiers = []string{"ci"}

13 )

14

15 func CreateQueue(t *testing.T, client *gophercloud.ServiceClient) (string, error) {

16 queueName := tools.RandomString("ACPTTEST", 5)

39 }

40

41 func DeleteQueue(t *testing.T, client *gophercloud.ServiceClient, queueName string) {

42 t.Logf("Attempting to delete Queue: %s", queueName)

43 err := queues.Delete(client, queueName).ExtractErr()

49 }

50

51 func GetQueue(t *testing.T, client *gophercloud.ServiceClient, queueName string) (queues.QueueDetails, error) {

52 t.Logf("Attempting to get Queue: %s", queueName)

53 queue, err := queues.Get(client, queueName).Extract()

58 }

59

60 func CreateShare(t *testing.T, client *gophercloud.ServiceClient, queueName string) (queues.QueueShare, error) {

61 t.Logf("Attempting to create share for queue: %s", queueName)

62

15 )

16

17 func TestServiceClassConverter_ToGQL(t *testing.T) {

18 var mockTimeStamp metav1.Time

19 var zeroTimeStamp time.Time

20 t.Run("All properties are given", func(t *testing.T) {

21 converter := serviceClassConverter{}

22

83 })

84

85 t.Run("Invalid externalMetadata (not equals to maps[string]string)", func(t *testing.T) {

86 converter := serviceClassConverter{}

87 maps := "randomString"