zz_generated.chaosmesh_test.go

Documentation: github.com/chaos-mesh/chaos-mesh/api/v1alpha1

     1  // Copyright 2020 Chaos Mesh Authors.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // See the License for the specific language governing permissions and
    12  // limitations under the License.
    13  
    14  package v1alpha1
    15  
    16  import (
    17  	"reflect"
    18  	"testing"
    19  	"time"
    20  
    21  	"github.com/bxcodec/faker"
    22  	. "github.com/onsi/gomega"
    23  )
    24  
    25  func TestAwsChaosIsDeleted(t *testing.T) {
    26  	g := NewGomegaWithT(t)
    27  
    28  	chaos := &AwsChaos{}
    29  	err := faker.FakeData(chaos)
    30  
    31  	g.Expect(err).To(BeNil())
    32  
    33  	chaos.IsDeleted()
    34  }
    35  
    36  func TestAwsChaosIsIsPaused(t *testing.T) {
    37  	g := NewGomegaWithT(t)
    38  
    39  	chaos := &AwsChaos{}
    40  	err := faker.FakeData(chaos)
    41  
    42  	g.Expect(err).To(BeNil())
    43  
    44  	chaos.IsPaused()
    45  }
    46  
    47  func TestAwsChaosGetDuration(t *testing.T) {
    48  	g := NewGomegaWithT(t)
    49  
    50  	chaos := &AwsChaos{}
    51  	err := faker.FakeData(chaos)
    52  
    53  	g.Expect(err).To(BeNil())
    54  
    55  	chaos.GetDuration()
    56  }
    57  
    58  func TestAwsChaosGetNextStart(t *testing.T) {
    59  	g := NewGomegaWithT(t)
    60  
    61  	chaos := &AwsChaos{}
    62  	err := faker.FakeData(chaos)
    63  
    64  	g.Expect(err).To(BeNil())
    65  
    66  	chaos.GetNextStart()
    67  }
    68  
    69  func TestAwsChaosSetNextStart(t *testing.T) {
    70  	g := NewGomegaWithT(t)
    71  
    72  	chaos := &AwsChaos{}
    73  	err := faker.FakeData(chaos)
    74  
    75  	g.Expect(err).To(BeNil())
    76  
    77  	chaos.SetNextStart(time.Now())
    78  }
    79  
    80  func TestAwsChaosGetNextRecover(t *testing.T) {
    81  	g := NewGomegaWithT(t)
    82  
    83  	chaos := &AwsChaos{}
    84  	err := faker.FakeData(chaos)
    85  
    86  	g.Expect(err).To(BeNil())
    87  
    88  	chaos.GetNextRecover()
    89  }
    90  
    91  func TestAwsChaosSetNextRecover(t *testing.T) {
    92  	g := NewGomegaWithT(t)
    93  
    94  	chaos := &AwsChaos{}
    95  	err := faker.FakeData(chaos)
    96  
    97  	g.Expect(err).To(BeNil())
    98  
    99  	chaos.SetNextRecover(time.Now())
   100  }
   101  
   102  func TestAwsChaosGetScheduler(t *testing.T) {
   103  	g := NewGomegaWithT(t)
   104  
   105  	chaos := &AwsChaos{}
   106  	err := faker.FakeData(chaos)
   107  
   108  	g.Expect(err).To(BeNil())
   109  
   110  	chaos.GetScheduler()
   111  }
   112  
   113  func TestAwsChaosGetChaos(t *testing.T) {
   114  	g := NewGomegaWithT(t)
   115  
   116  	chaos := &AwsChaos{}
   117  	err := faker.FakeData(chaos)
   118  
   119  	g.Expect(err).To(BeNil())
   120  
   121  	chaos.GetChaos()
   122  }
   123  
   124  func TestAwsChaosGetStatus(t *testing.T) {
   125  	g := NewGomegaWithT(t)
   126  
   127  	chaos := &AwsChaos{}
   128  	err := faker.FakeData(chaos)
   129  
   130  	g.Expect(err).To(BeNil())
   131  
   132  	chaos.GetStatus()
   133  }
   134  
   135  func TestAwsChaosGetSpecAndMetaString(t *testing.T) {
   136  	g := NewGomegaWithT(t)
   137  	chaos := &AwsChaos{}
   138  	err := faker.FakeData(chaos)
   139  	g.Expect(err).To(BeNil())
   140  	chaos.GetSpecAndMetaString()
   141  }
   142  
   143  func TestAwsChaosListChaos(t *testing.T) {
   144  	g := NewGomegaWithT(t)
   145  
   146  	chaos := &AwsChaosList{}
   147  	err := faker.FakeData(chaos)
   148  
   149  	g.Expect(err).To(BeNil())
   150  
   151  	chaos.ListChaos()
   152  }
   153  
   154  func TestDNSChaosIsDeleted(t *testing.T) {
   155  	g := NewGomegaWithT(t)
   156  
   157  	chaos := &DNSChaos{}
   158  	err := faker.FakeData(chaos)
   159  
   160  	g.Expect(err).To(BeNil())
   161  
   162  	chaos.IsDeleted()
   163  }
   164  
   165  func TestDNSChaosIsIsPaused(t *testing.T) {
   166  	g := NewGomegaWithT(t)
   167  
   168  	chaos := &DNSChaos{}
   169  	err := faker.FakeData(chaos)
   170  
   171  	g.Expect(err).To(BeNil())
   172  
   173  	chaos.IsPaused()
   174  }
   175  
   176  func TestDNSChaosGetDuration(t *testing.T) {
   177  	g := NewGomegaWithT(t)
   178  
   179  	chaos := &DNSChaos{}
   180  	err := faker.FakeData(chaos)
   181  
   182  	g.Expect(err).To(BeNil())
   183  
   184  	chaos.GetDuration()
   185  }
   186  
   187  func TestDNSChaosGetNextStart(t *testing.T) {
   188  	g := NewGomegaWithT(t)
   189  
   190  	chaos := &DNSChaos{}
   191  	err := faker.FakeData(chaos)
   192  
   193  	g.Expect(err).To(BeNil())
   194  
   195  	chaos.GetNextStart()
   196  }
   197  
   198  func TestDNSChaosSetNextStart(t *testing.T) {
   199  	g := NewGomegaWithT(t)
   200  
   201  	chaos := &DNSChaos{}
   202  	err := faker.FakeData(chaos)
   203  
   204  	g.Expect(err).To(BeNil())
   205  
   206  	chaos.SetNextStart(time.Now())
   207  }
   208  
   209  func TestDNSChaosGetNextRecover(t *testing.T) {
   210  	g := NewGomegaWithT(t)
   211  
   212  	chaos := &DNSChaos{}
   213  	err := faker.FakeData(chaos)
   214  
   215  	g.Expect(err).To(BeNil())
   216  
   217  	chaos.GetNextRecover()
   218  }
   219  
   220  func TestDNSChaosSetNextRecover(t *testing.T) {
   221  	g := NewGomegaWithT(t)
   222  
   223  	chaos := &DNSChaos{}
   224  	err := faker.FakeData(chaos)
   225  
   226  	g.Expect(err).To(BeNil())
   227  
   228  	chaos.SetNextRecover(time.Now())
   229  }
   230  
   231  func TestDNSChaosGetScheduler(t *testing.T) {
   232  	g := NewGomegaWithT(t)
   233  
   234  	chaos := &DNSChaos{}
   235  	err := faker.FakeData(chaos)
   236  
   237  	g.Expect(err).To(BeNil())
   238  
   239  	chaos.GetScheduler()
   240  }
   241  
   242  func TestDNSChaosGetChaos(t *testing.T) {
   243  	g := NewGomegaWithT(t)
   244  
   245  	chaos := &DNSChaos{}
   246  	err := faker.FakeData(chaos)
   247  
   248  	g.Expect(err).To(BeNil())
   249  
   250  	chaos.GetChaos()
   251  }
   252  
   253  func TestDNSChaosGetStatus(t *testing.T) {
   254  	g := NewGomegaWithT(t)
   255  
   256  	chaos := &DNSChaos{}
   257  	err := faker.FakeData(chaos)
   258  
   259  	g.Expect(err).To(BeNil())
   260  
   261  	chaos.GetStatus()
   262  }
   263  
   264  func TestDNSChaosGetSpecAndMetaString(t *testing.T) {
   265  	g := NewGomegaWithT(t)
   266  	chaos := &DNSChaos{}
   267  	err := faker.FakeData(chaos)
   268  	g.Expect(err).To(BeNil())
   269  	chaos.GetSpecAndMetaString()
   270  }
   271  
   272  func TestDNSChaosListChaos(t *testing.T) {
   273  	g := NewGomegaWithT(t)
   274  
   275  	chaos := &DNSChaosList{}
   276  	err := faker.FakeData(chaos)
   277  
   278  	g.Expect(err).To(BeNil())
   279  
   280  	chaos.ListChaos()
   281  }
   282  
   283  func TestHTTPChaosIsDeleted(t *testing.T) {
   284  	g := NewGomegaWithT(t)
   285  
   286  	chaos := &HTTPChaos{}
   287  	err := faker.FakeData(chaos)
   288  
   289  	g.Expect(err).To(BeNil())
   290  
   291  	chaos.IsDeleted()
   292  }
   293  
   294  func TestHTTPChaosIsIsPaused(t *testing.T) {
   295  	g := NewGomegaWithT(t)
   296  
   297  	chaos := &HTTPChaos{}
   298  	err := faker.FakeData(chaos)
   299  
   300  	g.Expect(err).To(BeNil())
   301  
   302  	chaos.IsPaused()
   303  }
   304  
   305  func TestHTTPChaosGetDuration(t *testing.T) {
   306  	g := NewGomegaWithT(t)
   307  
   308  	chaos := &HTTPChaos{}
   309  	err := faker.FakeData(chaos)
   310  
   311  	g.Expect(err).To(BeNil())
   312  
   313  	chaos.GetDuration()
   314  }
   315  
   316  func TestHTTPChaosGetNextStart(t *testing.T) {
   317  	g := NewGomegaWithT(t)
   318  
   319  	chaos := &HTTPChaos{}
   320  	err := faker.FakeData(chaos)
   321  
   322  	g.Expect(err).To(BeNil())
   323  
   324  	chaos.GetNextStart()
   325  }
   326  
   327  func TestHTTPChaosSetNextStart(t *testing.T) {
   328  	g := NewGomegaWithT(t)
   329  
   330  	chaos := &HTTPChaos{}
   331  	err := faker.FakeData(chaos)
   332  
   333  	g.Expect(err).To(BeNil())
   334  
   335  	chaos.SetNextStart(time.Now())
   336  }
   337  
   338  func TestHTTPChaosGetNextRecover(t *testing.T) {
   339  	g := NewGomegaWithT(t)
   340  
   341  	chaos := &HTTPChaos{}
   342  	err := faker.FakeData(chaos)
   343  
   344  	g.Expect(err).To(BeNil())
   345  
   346  	chaos.GetNextRecover()
   347  }
   348  
   349  func TestHTTPChaosSetNextRecover(t *testing.T) {
   350  	g := NewGomegaWithT(t)
   351  
   352  	chaos := &HTTPChaos{}
   353  	err := faker.FakeData(chaos)
   354  
   355  	g.Expect(err).To(BeNil())
   356  
   357  	chaos.SetNextRecover(time.Now())
   358  }
   359  
   360  func TestHTTPChaosGetScheduler(t *testing.T) {
   361  	g := NewGomegaWithT(t)
   362  
   363  	chaos := &HTTPChaos{}
   364  	err := faker.FakeData(chaos)
   365  
   366  	g.Expect(err).To(BeNil())
   367  
   368  	chaos.GetScheduler()
   369  }
   370  
   371  func TestHTTPChaosGetChaos(t *testing.T) {
   372  	g := NewGomegaWithT(t)
   373  
   374  	chaos := &HTTPChaos{}
   375  	err := faker.FakeData(chaos)
   376  
   377  	g.Expect(err).To(BeNil())
   378  
   379  	chaos.GetChaos()
   380  }
   381  
   382  func TestHTTPChaosGetStatus(t *testing.T) {
   383  	g := NewGomegaWithT(t)
   384  
   385  	chaos := &HTTPChaos{}
   386  	err := faker.FakeData(chaos)
   387  
   388  	g.Expect(err).To(BeNil())
   389  
   390  	chaos.GetStatus()
   391  }
   392  
   393  func TestHTTPChaosGetSpecAndMetaString(t *testing.T) {
   394  	g := NewGomegaWithT(t)
   395  	chaos := &HTTPChaos{}
   396  	err := faker.FakeData(chaos)
   397  	g.Expect(err).To(BeNil())
   398  	chaos.GetSpecAndMetaString()
   399  }
   400  
   401  func TestHTTPChaosListChaos(t *testing.T) {
   402  	g := NewGomegaWithT(t)
   403  
   404  	chaos := &HTTPChaosList{}
   405  	err := faker.FakeData(chaos)
   406  
   407  	g.Expect(err).To(BeNil())
   408  
   409  	chaos.ListChaos()
   410  }
   411  
   412  func TestIoChaosIsDeleted(t *testing.T) {
   413  	g := NewGomegaWithT(t)
   414  
   415  	chaos := &IoChaos{}
   416  	err := faker.FakeData(chaos)
   417  
   418  	g.Expect(err).To(BeNil())
   419  
   420  	chaos.IsDeleted()
   421  }
   422  
   423  func TestIoChaosIsIsPaused(t *testing.T) {
   424  	g := NewGomegaWithT(t)
   425  
   426  	chaos := &IoChaos{}
   427  	err := faker.FakeData(chaos)
   428  
   429  	g.Expect(err).To(BeNil())
   430  
   431  	chaos.IsPaused()
   432  }
   433  
   434  func TestIoChaosGetDuration(t *testing.T) {
   435  	g := NewGomegaWithT(t)
   436  
   437  	chaos := &IoChaos{}
   438  	err := faker.FakeData(chaos)
   439  
   440  	g.Expect(err).To(BeNil())
   441  
   442  	chaos.GetDuration()
   443  }
   444  
   445  func TestIoChaosGetNextStart(t *testing.T) {
   446  	g := NewGomegaWithT(t)
   447  
   448  	chaos := &IoChaos{}
   449  	err := faker.FakeData(chaos)
   450  
   451  	g.Expect(err).To(BeNil())
   452  
   453  	chaos.GetNextStart()
   454  }
   455  
   456  func TestIoChaosSetNextStart(t *testing.T) {
   457  	g := NewGomegaWithT(t)
   458  
   459  	chaos := &IoChaos{}
   460  	err := faker.FakeData(chaos)
   461  
   462  	g.Expect(err).To(BeNil())
   463  
   464  	chaos.SetNextStart(time.Now())
   465  }
   466  
   467  func TestIoChaosGetNextRecover(t *testing.T) {
   468  	g := NewGomegaWithT(t)
   469  
   470  	chaos := &IoChaos{}
   471  	err := faker.FakeData(chaos)
   472  
   473  	g.Expect(err).To(BeNil())
   474  
   475  	chaos.GetNextRecover()
   476  }
   477  
   478  func TestIoChaosSetNextRecover(t *testing.T) {
   479  	g := NewGomegaWithT(t)
   480  
   481  	chaos := &IoChaos{}
   482  	err := faker.FakeData(chaos)
   483  
   484  	g.Expect(err).To(BeNil())
   485  
   486  	chaos.SetNextRecover(time.Now())
   487  }
   488  
   489  func TestIoChaosGetScheduler(t *testing.T) {
   490  	g := NewGomegaWithT(t)
   491  
   492  	chaos := &IoChaos{}
   493  	err := faker.FakeData(chaos)
   494  
   495  	g.Expect(err).To(BeNil())
   496  
   497  	chaos.GetScheduler()
   498  }
   499  
   500  func TestIoChaosGetChaos(t *testing.T) {
   501  	g := NewGomegaWithT(t)
   502  
   503  	chaos := &IoChaos{}
   504  	err := faker.FakeData(chaos)
   505  
   506  	g.Expect(err).To(BeNil())
   507  
   508  	chaos.GetChaos()
   509  }
   510  
   511  func TestIoChaosGetStatus(t *testing.T) {
   512  	g := NewGomegaWithT(t)
   513  
   514  	chaos := &IoChaos{}
   515  	err := faker.FakeData(chaos)
   516  
   517  	g.Expect(err).To(BeNil())
   518  
   519  	chaos.GetStatus()
   520  }
   521  
   522  func TestIoChaosGetSpecAndMetaString(t *testing.T) {
   523  	g := NewGomegaWithT(t)
   524  	chaos := &IoChaos{}
   525  	err := faker.FakeData(chaos)
   526  	g.Expect(err).To(BeNil())
   527  	chaos.GetSpecAndMetaString()
   528  }
   529  
   530  func TestIoChaosListChaos(t *testing.T) {
   531  	g := NewGomegaWithT(t)
   532  
   533  	chaos := &IoChaosList{}
   534  	err := faker.FakeData(chaos)
   535  
   536  	g.Expect(err).To(BeNil())
   537  
   538  	chaos.ListChaos()
   539  }
   540  
   541  func TestJVMChaosIsDeleted(t *testing.T) {
   542  	g := NewGomegaWithT(t)
   543  
   544  	chaos := &JVMChaos{}
   545  	err := faker.FakeData(chaos)
   546  
   547  	g.Expect(err).To(BeNil())
   548  
   549  	chaos.IsDeleted()
   550  }
   551  
   552  func TestJVMChaosIsIsPaused(t *testing.T) {
   553  	g := NewGomegaWithT(t)
   554  
   555  	chaos := &JVMChaos{}
   556  	err := faker.FakeData(chaos)
   557  
   558  	g.Expect(err).To(BeNil())
   559  
   560  	chaos.IsPaused()
   561  }
   562  
   563  func TestJVMChaosGetDuration(t *testing.T) {
   564  	g := NewGomegaWithT(t)
   565  
   566  	chaos := &JVMChaos{}
   567  	err := faker.FakeData(chaos)
   568  
   569  	g.Expect(err).To(BeNil())
   570  
   571  	chaos.GetDuration()
   572  }
   573  
   574  func TestJVMChaosGetNextStart(t *testing.T) {
   575  	g := NewGomegaWithT(t)
   576  
   577  	chaos := &JVMChaos{}
   578  	err := faker.FakeData(chaos)
   579  
   580  	g.Expect(err).To(BeNil())
   581  
   582  	chaos.GetNextStart()
   583  }
   584  
   585  func TestJVMChaosSetNextStart(t *testing.T) {
   586  	g := NewGomegaWithT(t)
   587  
   588  	chaos := &JVMChaos{}
   589  	err := faker.FakeData(chaos)
   590  
   591  	g.Expect(err).To(BeNil())
   592  
   593  	chaos.SetNextStart(time.Now())
   594  }
   595  
   596  func TestJVMChaosGetNextRecover(t *testing.T) {
   597  	g := NewGomegaWithT(t)
   598  
   599  	chaos := &JVMChaos{}
   600  	err := faker.FakeData(chaos)
   601  
   602  	g.Expect(err).To(BeNil())
   603  
   604  	chaos.GetNextRecover()
   605  }
   606  
   607  func TestJVMChaosSetNextRecover(t *testing.T) {
   608  	g := NewGomegaWithT(t)
   609  
   610  	chaos := &JVMChaos{}
   611  	err := faker.FakeData(chaos)
   612  
   613  	g.Expect(err).To(BeNil())
   614  
   615  	chaos.SetNextRecover(time.Now())
   616  }
   617  
   618  func TestJVMChaosGetScheduler(t *testing.T) {
   619  	g := NewGomegaWithT(t)
   620  
   621  	chaos := &JVMChaos{}
   622  	err := faker.FakeData(chaos)
   623  
   624  	g.Expect(err).To(BeNil())
   625  
   626  	chaos.GetScheduler()
   627  }
   628  
   629  func TestJVMChaosGetChaos(t *testing.T) {
   630  	g := NewGomegaWithT(t)
   631  
   632  	chaos := &JVMChaos{}
   633  	err := faker.FakeData(chaos)
   634  
   635  	g.Expect(err).To(BeNil())
   636  
   637  	chaos.GetChaos()
   638  }
   639  
   640  func TestJVMChaosGetStatus(t *testing.T) {
   641  	g := NewGomegaWithT(t)
   642  
   643  	chaos := &JVMChaos{}
   644  	err := faker.FakeData(chaos)
   645  
   646  	g.Expect(err).To(BeNil())
   647  
   648  	chaos.GetStatus()
   649  }
   650  
   651  func TestJVMChaosGetSpecAndMetaString(t *testing.T) {
   652  	g := NewGomegaWithT(t)
   653  	chaos := &JVMChaos{}
   654  	err := faker.FakeData(chaos)
   655  	g.Expect(err).To(BeNil())
   656  	chaos.GetSpecAndMetaString()
   657  }
   658  
   659  func TestJVMChaosListChaos(t *testing.T) {
   660  	g := NewGomegaWithT(t)
   661  
   662  	chaos := &JVMChaosList{}
   663  	err := faker.FakeData(chaos)
   664  
   665  	g.Expect(err).To(BeNil())
   666  
   667  	chaos.ListChaos()
   668  }
   669  
   670  func TestKernelChaosIsDeleted(t *testing.T) {
   671  	g := NewGomegaWithT(t)
   672  
   673  	chaos := &KernelChaos{}
   674  	err := faker.FakeData(chaos)
   675  
   676  	g.Expect(err).To(BeNil())
   677  
   678  	chaos.IsDeleted()
   679  }
   680  
   681  func TestKernelChaosIsIsPaused(t *testing.T) {
   682  	g := NewGomegaWithT(t)
   683  
   684  	chaos := &KernelChaos{}
   685  	err := faker.FakeData(chaos)
   686  
   687  	g.Expect(err).To(BeNil())
   688  
   689  	chaos.IsPaused()
   690  }
   691  
   692  func TestKernelChaosGetDuration(t *testing.T) {
   693  	g := NewGomegaWithT(t)
   694  
   695  	chaos := &KernelChaos{}
   696  	err := faker.FakeData(chaos)
   697  
   698  	g.Expect(err).To(BeNil())
   699  
   700  	chaos.GetDuration()
   701  }
   702  
   703  func TestKernelChaosGetNextStart(t *testing.T) {
   704  	g := NewGomegaWithT(t)
   705  
   706  	chaos := &KernelChaos{}
   707  	err := faker.FakeData(chaos)
   708  
   709  	g.Expect(err).To(BeNil())
   710  
   711  	chaos.GetNextStart()
   712  }
   713  
   714  func TestKernelChaosSetNextStart(t *testing.T) {
   715  	g := NewGomegaWithT(t)
   716  
   717  	chaos := &KernelChaos{}
   718  	err := faker.FakeData(chaos)
   719  
   720  	g.Expect(err).To(BeNil())
   721  
   722  	chaos.SetNextStart(time.Now())
   723  }
   724  
   725  func TestKernelChaosGetNextRecover(t *testing.T) {
   726  	g := NewGomegaWithT(t)
   727  
   728  	chaos := &KernelChaos{}
   729  	err := faker.FakeData(chaos)
   730  
   731  	g.Expect(err).To(BeNil())
   732  
   733  	chaos.GetNextRecover()
   734  }
   735  
   736  func TestKernelChaosSetNextRecover(t *testing.T) {
   737  	g := NewGomegaWithT(t)
   738  
   739  	chaos := &KernelChaos{}
   740  	err := faker.FakeData(chaos)
   741  
   742  	g.Expect(err).To(BeNil())
   743  
   744  	chaos.SetNextRecover(time.Now())
   745  }
   746  
   747  func TestKernelChaosGetScheduler(t *testing.T) {
   748  	g := NewGomegaWithT(t)
   749  
   750  	chaos := &KernelChaos{}
   751  	err := faker.FakeData(chaos)
   752  
   753  	g.Expect(err).To(BeNil())
   754  
   755  	chaos.GetScheduler()
   756  }
   757  
   758  func TestKernelChaosGetChaos(t *testing.T) {
   759  	g := NewGomegaWithT(t)
   760  
   761  	chaos := &KernelChaos{}
   762  	err := faker.FakeData(chaos)
   763  
   764  	g.Expect(err).To(BeNil())
   765  
   766  	chaos.GetChaos()
   767  }
   768  
   769  func TestKernelChaosGetStatus(t *testing.T) {
   770  	g := NewGomegaWithT(t)
   771  
   772  	chaos := &KernelChaos{}
   773  	err := faker.FakeData(chaos)
   774  
   775  	g.Expect(err).To(BeNil())
   776  
   777  	chaos.GetStatus()
   778  }
   779  
   780  func TestKernelChaosGetSpecAndMetaString(t *testing.T) {
   781  	g := NewGomegaWithT(t)
   782  	chaos := &KernelChaos{}
   783  	err := faker.FakeData(chaos)
   784  	g.Expect(err).To(BeNil())
   785  	chaos.GetSpecAndMetaString()
   786  }
   787  
   788  func TestKernelChaosListChaos(t *testing.T) {
   789  	g := NewGomegaWithT(t)
   790  
   791  	chaos := &KernelChaosList{}
   792  	err := faker.FakeData(chaos)
   793  
   794  	g.Expect(err).To(BeNil())
   795  
   796  	chaos.ListChaos()
   797  }
   798  
   799  func TestNetworkChaosIsDeleted(t *testing.T) {
   800  	g := NewGomegaWithT(t)
   801  
   802  	chaos := &NetworkChaos{}
   803  	err := faker.FakeData(chaos)
   804  
   805  	g.Expect(err).To(BeNil())
   806  
   807  	chaos.IsDeleted()
   808  }
   809  
   810  func TestNetworkChaosIsIsPaused(t *testing.T) {
   811  	g := NewGomegaWithT(t)
   812  
   813  	chaos := &NetworkChaos{}
   814  	err := faker.FakeData(chaos)
   815  
   816  	g.Expect(err).To(BeNil())
   817  
   818  	chaos.IsPaused()
   819  }
   820  
   821  func TestNetworkChaosGetDuration(t *testing.T) {
   822  	g := NewGomegaWithT(t)
   823  
   824  	chaos := &NetworkChaos{}
   825  	err := faker.FakeData(chaos)
   826  
   827  	g.Expect(err).To(BeNil())
   828  
   829  	chaos.GetDuration()
   830  }
   831  
   832  func TestNetworkChaosGetNextStart(t *testing.T) {
   833  	g := NewGomegaWithT(t)
   834  
   835  	chaos := &NetworkChaos{}
   836  	err := faker.FakeData(chaos)
   837  
   838  	g.Expect(err).To(BeNil())
   839  
   840  	chaos.GetNextStart()
   841  }
   842  
   843  func TestNetworkChaosSetNextStart(t *testing.T) {
   844  	g := NewGomegaWithT(t)
   845  
   846  	chaos := &NetworkChaos{}
   847  	err := faker.FakeData(chaos)
   848  
   849  	g.Expect(err).To(BeNil())
   850  
   851  	chaos.SetNextStart(time.Now())
   852  }
   853  
   854  func TestNetworkChaosGetNextRecover(t *testing.T) {
   855  	g := NewGomegaWithT(t)
   856  
   857  	chaos := &NetworkChaos{}
   858  	err := faker.FakeData(chaos)
   859  
   860  	g.Expect(err).To(BeNil())
   861  
   862  	chaos.GetNextRecover()
   863  }
   864  
   865  func TestNetworkChaosSetNextRecover(t *testing.T) {
   866  	g := NewGomegaWithT(t)
   867  
   868  	chaos := &NetworkChaos{}
   869  	err := faker.FakeData(chaos)
   870  
   871  	g.Expect(err).To(BeNil())
   872  
   873  	chaos.SetNextRecover(time.Now())
   874  }
   875  
   876  func TestNetworkChaosGetScheduler(t *testing.T) {
   877  	g := NewGomegaWithT(t)
   878  
   879  	chaos := &NetworkChaos{}
   880  	err := faker.FakeData(chaos)
   881  
   882  	g.Expect(err).To(BeNil())
   883  
   884  	chaos.GetScheduler()
   885  }
   886  
   887  func TestNetworkChaosGetChaos(t *testing.T) {
   888  	g := NewGomegaWithT(t)
   889  
   890  	chaos := &NetworkChaos{}
   891  	err := faker.FakeData(chaos)
   892  
   893  	g.Expect(err).To(BeNil())
   894  
   895  	chaos.GetChaos()
   896  }
   897  
   898  func TestNetworkChaosGetStatus(t *testing.T) {
   899  	g := NewGomegaWithT(t)
   900  
   901  	chaos := &NetworkChaos{}
   902  	err := faker.FakeData(chaos)
   903  
   904  	g.Expect(err).To(BeNil())
   905  
   906  	chaos.GetStatus()
   907  }
   908  
   909  func TestNetworkChaosGetSpecAndMetaString(t *testing.T) {
   910  	g := NewGomegaWithT(t)
   911  	chaos := &NetworkChaos{}
   912  	err := faker.FakeData(chaos)
   913  	g.Expect(err).To(BeNil())
   914  	chaos.GetSpecAndMetaString()
   915  }
   916  
   917  func TestNetworkChaosListChaos(t *testing.T) {
   918  	g := NewGomegaWithT(t)
   919  
   920  	chaos := &NetworkChaosList{}
   921  	err := faker.FakeData(chaos)
   922  
   923  	g.Expect(err).To(BeNil())
   924  
   925  	chaos.ListChaos()
   926  }
   927  
   928  func TestPodChaosIsDeleted(t *testing.T) {
   929  	g := NewGomegaWithT(t)
   930  
   931  	chaos := &PodChaos{}
   932  	err := faker.FakeData(chaos)
   933  
   934  	g.Expect(err).To(BeNil())
   935  
   936  	chaos.IsDeleted()
   937  }
   938  
   939  func TestPodChaosIsIsPaused(t *testing.T) {
   940  	g := NewGomegaWithT(t)
   941  
   942  	chaos := &PodChaos{}
   943  	err := faker.FakeData(chaos)
   944  
   945  	g.Expect(err).To(BeNil())
   946  
   947  	chaos.IsPaused()
   948  }
   949  
   950  func TestPodChaosGetDuration(t *testing.T) {
   951  	g := NewGomegaWithT(t)
   952  
   953  	chaos := &PodChaos{}
   954  	err := faker.FakeData(chaos)
   955  
   956  	g.Expect(err).To(BeNil())
   957  
   958  	chaos.GetDuration()
   959  }
   960  
   961  func TestPodChaosGetNextStart(t *testing.T) {
   962  	g := NewGomegaWithT(t)
   963  
   964  	chaos := &PodChaos{}
   965  	err := faker.FakeData(chaos)
   966  
   967  	g.Expect(err).To(BeNil())
   968  
   969  	chaos.GetNextStart()
   970  }
   971  
   972  func TestPodChaosSetNextStart(t *testing.T) {
   973  	g := NewGomegaWithT(t)
   974  
   975  	chaos := &PodChaos{}
   976  	err := faker.FakeData(chaos)
   977  
   978  	g.Expect(err).To(BeNil())
   979  
   980  	chaos.SetNextStart(time.Now())
   981  }
   982  
   983  func TestPodChaosGetNextRecover(t *testing.T) {
   984  	g := NewGomegaWithT(t)
   985  
   986  	chaos := &PodChaos{}
   987  	err := faker.FakeData(chaos)
   988  
   989  	g.Expect(err).To(BeNil())
   990  
   991  	chaos.GetNextRecover()
   992  }
   993  
   994  func TestPodChaosSetNextRecover(t *testing.T) {
   995  	g := NewGomegaWithT(t)
   996  
   997  	chaos := &PodChaos{}
   998  	err := faker.FakeData(chaos)
   999  
  1000  	g.Expect(err).To(BeNil())
  1001  
  1002  	chaos.SetNextRecover(time.Now())
  1003  }
  1004  
  1005  func TestPodChaosGetScheduler(t *testing.T) {
  1006  	g := NewGomegaWithT(t)
  1007  
  1008  	chaos := &PodChaos{}
  1009  	err := faker.FakeData(chaos)
  1010  
  1011  	g.Expect(err).To(BeNil())
  1012  
  1013  	chaos.GetScheduler()
  1014  }
  1015  
  1016  func TestPodChaosGetChaos(t *testing.T) {
  1017  	g := NewGomegaWithT(t)
  1018  
  1019  	chaos := &PodChaos{}
  1020  	err := faker.FakeData(chaos)
  1021  
  1022  	g.Expect(err).To(BeNil())
  1023  
  1024  	chaos.GetChaos()
  1025  }
  1026  
  1027  func TestPodChaosGetStatus(t *testing.T) {
  1028  	g := NewGomegaWithT(t)
  1029  
  1030  	chaos := &PodChaos{}
  1031  	err := faker.FakeData(chaos)
  1032  
  1033  	g.Expect(err).To(BeNil())
  1034  
  1035  	chaos.GetStatus()
  1036  }
  1037  
  1038  func TestPodChaosGetSpecAndMetaString(t *testing.T) {
  1039  	g := NewGomegaWithT(t)
  1040  	chaos := &PodChaos{}
  1041  	err := faker.FakeData(chaos)
  1042  	g.Expect(err).To(BeNil())
  1043  	chaos.GetSpecAndMetaString()
  1044  }
  1045  
  1046  func TestPodChaosListChaos(t *testing.T) {
  1047  	g := NewGomegaWithT(t)
  1048  
  1049  	chaos := &PodChaosList{}
  1050  	err := faker.FakeData(chaos)
  1051  
  1052  	g.Expect(err).To(BeNil())
  1053  
  1054  	chaos.ListChaos()
  1055  }
  1056  
  1057  func TestStressChaosIsDeleted(t *testing.T) {
  1058  	g := NewGomegaWithT(t)
  1059  
  1060  	chaos := &StressChaos{}
  1061  	err := faker.FakeData(chaos)
  1062  
  1063  	g.Expect(err).To(BeNil())
  1064  
  1065  	chaos.IsDeleted()
  1066  }
  1067  
  1068  func TestStressChaosIsIsPaused(t *testing.T) {
  1069  	g := NewGomegaWithT(t)
  1070  
  1071  	chaos := &StressChaos{}
  1072  	err := faker.FakeData(chaos)
  1073  
  1074  	g.Expect(err).To(BeNil())
  1075  
  1076  	chaos.IsPaused()
  1077  }
  1078  
  1079  func TestStressChaosGetDuration(t *testing.T) {
  1080  	g := NewGomegaWithT(t)
  1081  
  1082  	chaos := &StressChaos{}
  1083  	err := faker.FakeData(chaos)
  1084  
  1085  	g.Expect(err).To(BeNil())
  1086  
  1087  	chaos.GetDuration()
  1088  }
  1089  
  1090  func TestStressChaosGetNextStart(t *testing.T) {
  1091  	g := NewGomegaWithT(t)
  1092  
  1093  	chaos := &StressChaos{}
  1094  	err := faker.FakeData(chaos)
  1095  
  1096  	g.Expect(err).To(BeNil())
  1097  
  1098  	chaos.GetNextStart()
  1099  }
  1100  
  1101  func TestStressChaosSetNextStart(t *testing.T) {
  1102  	g := NewGomegaWithT(t)
  1103  
  1104  	chaos := &StressChaos{}
  1105  	err := faker.FakeData(chaos)
  1106  
  1107  	g.Expect(err).To(BeNil())
  1108  
  1109  	chaos.SetNextStart(time.Now())
  1110  }
  1111  
  1112  func TestStressChaosGetNextRecover(t *testing.T) {
  1113  	g := NewGomegaWithT(t)
  1114  
  1115  	chaos := &StressChaos{}
  1116  	err := faker.FakeData(chaos)
  1117  
  1118  	g.Expect(err).To(BeNil())
  1119  
  1120  	chaos.GetNextRecover()
  1121  }
  1122  
  1123  func TestStressChaosSetNextRecover(t *testing.T) {
  1124  	g := NewGomegaWithT(t)
  1125  
  1126  	chaos := &StressChaos{}
  1127  	err := faker.FakeData(chaos)
  1128  
  1129  	g.Expect(err).To(BeNil())
  1130  
  1131  	chaos.SetNextRecover(time.Now())
  1132  }
  1133  
  1134  func TestStressChaosGetScheduler(t *testing.T) {
  1135  	g := NewGomegaWithT(t)
  1136  
  1137  	chaos := &StressChaos{}
  1138  	err := faker.FakeData(chaos)
  1139  
  1140  	g.Expect(err).To(BeNil())
  1141  
  1142  	chaos.GetScheduler()
  1143  }
  1144  
  1145  func TestStressChaosGetChaos(t *testing.T) {
  1146  	g := NewGomegaWithT(t)
  1147  
  1148  	chaos := &StressChaos{}
  1149  	err := faker.FakeData(chaos)
  1150  
  1151  	g.Expect(err).To(BeNil())
  1152  
  1153  	chaos.GetChaos()
  1154  }
  1155  
  1156  func TestStressChaosGetStatus(t *testing.T) {
  1157  	g := NewGomegaWithT(t)
  1158  
  1159  	chaos := &StressChaos{}
  1160  	err := faker.FakeData(chaos)
  1161  
  1162  	g.Expect(err).To(BeNil())
  1163  
  1164  	chaos.GetStatus()
  1165  }
  1166  
  1167  func TestStressChaosGetSpecAndMetaString(t *testing.T) {
  1168  	g := NewGomegaWithT(t)
  1169  	chaos := &StressChaos{}
  1170  	err := faker.FakeData(chaos)
  1171  	g.Expect(err).To(BeNil())
  1172  	chaos.GetSpecAndMetaString()
  1173  }
  1174  
  1175  func TestStressChaosListChaos(t *testing.T) {
  1176  	g := NewGomegaWithT(t)
  1177  
  1178  	chaos := &StressChaosList{}
  1179  	err := faker.FakeData(chaos)
  1180  
  1181  	g.Expect(err).To(BeNil())
  1182  
  1183  	chaos.ListChaos()
  1184  }
  1185  
  1186  func TestTimeChaosIsDeleted(t *testing.T) {
  1187  	g := NewGomegaWithT(t)
  1188  
  1189  	chaos := &TimeChaos{}
  1190  	err := faker.FakeData(chaos)
  1191  
  1192  	g.Expect(err).To(BeNil())
  1193  
  1194  	chaos.IsDeleted()
  1195  }
  1196  
  1197  func TestTimeChaosIsIsPaused(t *testing.T) {
  1198  	g := NewGomegaWithT(t)
  1199  
  1200  	chaos := &TimeChaos{}
  1201  	err := faker.FakeData(chaos)
  1202  
  1203  	g.Expect(err).To(BeNil())
  1204  
  1205  	chaos.IsPaused()
  1206  }
  1207  
  1208  func TestTimeChaosGetDuration(t *testing.T) {
  1209  	g := NewGomegaWithT(t)
  1210  
  1211  	chaos := &TimeChaos{}
  1212  	err := faker.FakeData(chaos)
  1213  
  1214  	g.Expect(err).To(BeNil())
  1215  
  1216  	chaos.GetDuration()
  1217  }
  1218  
  1219  func TestTimeChaosGetNextStart(t *testing.T) {
  1220  	g := NewGomegaWithT(t)
  1221  
  1222  	chaos := &TimeChaos{}
  1223  	err := faker.FakeData(chaos)
  1224  
  1225  	g.Expect(err).To(BeNil())
  1226  
  1227  	chaos.GetNextStart()
  1228  }
  1229  
  1230  func TestTimeChaosSetNextStart(t *testing.T) {
  1231  	g := NewGomegaWithT(t)
  1232  
  1233  	chaos := &TimeChaos{}
  1234  	err := faker.FakeData(chaos)
  1235  
  1236  	g.Expect(err).To(BeNil())
  1237  
  1238  	chaos.SetNextStart(time.Now())
  1239  }
  1240  
  1241  func TestTimeChaosGetNextRecover(t *testing.T) {
  1242  	g := NewGomegaWithT(t)
  1243  
  1244  	chaos := &TimeChaos{}
  1245  	err := faker.FakeData(chaos)
  1246  
  1247  	g.Expect(err).To(BeNil())
  1248  
  1249  	chaos.GetNextRecover()
  1250  }
  1251  
  1252  func TestTimeChaosSetNextRecover(t *testing.T) {
  1253  	g := NewGomegaWithT(t)
  1254  
  1255  	chaos := &TimeChaos{}
  1256  	err := faker.FakeData(chaos)
  1257  
  1258  	g.Expect(err).To(BeNil())
  1259  
  1260  	chaos.SetNextRecover(time.Now())
  1261  }
  1262  
  1263  func TestTimeChaosGetScheduler(t *testing.T) {
  1264  	g := NewGomegaWithT(t)
  1265  
  1266  	chaos := &TimeChaos{}
  1267  	err := faker.FakeData(chaos)
  1268  
  1269  	g.Expect(err).To(BeNil())
  1270  
  1271  	chaos.GetScheduler()
  1272  }
  1273  
  1274  func TestTimeChaosGetChaos(t *testing.T) {
  1275  	g := NewGomegaWithT(t)
  1276  
  1277  	chaos := &TimeChaos{}
  1278  	err := faker.FakeData(chaos)
  1279  
  1280  	g.Expect(err).To(BeNil())
  1281  
  1282  	chaos.GetChaos()
  1283  }
  1284  
  1285  func TestTimeChaosGetStatus(t *testing.T) {
  1286  	g := NewGomegaWithT(t)
  1287  
  1288  	chaos := &TimeChaos{}
  1289  	err := faker.FakeData(chaos)
  1290  
  1291  	g.Expect(err).To(BeNil())
  1292  
  1293  	chaos.GetStatus()
  1294  }
  1295  
  1296  func TestTimeChaosGetSpecAndMetaString(t *testing.T) {
  1297  	g := NewGomegaWithT(t)
  1298  	chaos := &TimeChaos{}
  1299  	err := faker.FakeData(chaos)
  1300  	g.Expect(err).To(BeNil())
  1301  	chaos.GetSpecAndMetaString()
  1302  }
  1303  
  1304  func TestTimeChaosListChaos(t *testing.T) {
  1305  	g := NewGomegaWithT(t)
  1306  
  1307  	chaos := &TimeChaosList{}
  1308  	err := faker.FakeData(chaos)
  1309  
  1310  	g.Expect(err).To(BeNil())
  1311  
  1312  	chaos.ListChaos()
  1313  }
  1314  
  1315  func init() {
  1316  	faker.AddProvider("ioMethods", func(v reflect.Value) (interface{}, error) {
  1317  		return []IoMethod{LookUp}, nil
  1318  	})
  1319  }
  1320