github.com/goravel/framework@v1.13.9/foundation/application_test.go (about)

     1  package foundation
     2  
     3  import (
     4  	"path/filepath"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/suite"
     9  
    10  	"github.com/goravel/framework/auth"
    11  	"github.com/goravel/framework/cache"
    12  	"github.com/goravel/framework/config"
    13  	"github.com/goravel/framework/console"
    14  	cachemocks "github.com/goravel/framework/contracts/cache/mocks"
    15  	configmocks "github.com/goravel/framework/contracts/config/mocks"
    16  	consolemocks "github.com/goravel/framework/contracts/console/mocks"
    17  	"github.com/goravel/framework/contracts/database/orm"
    18  	ormmocks "github.com/goravel/framework/contracts/database/orm/mocks"
    19  	"github.com/goravel/framework/contracts/foundation"
    20  	logmocks "github.com/goravel/framework/contracts/log/mocks"
    21  	queuemocks "github.com/goravel/framework/contracts/queue/mocks"
    22  	routemocks "github.com/goravel/framework/contracts/route/mocks"
    23  	"github.com/goravel/framework/crypt"
    24  	"github.com/goravel/framework/database"
    25  	"github.com/goravel/framework/database/gorm"
    26  	"github.com/goravel/framework/event"
    27  	"github.com/goravel/framework/filesystem"
    28  	"github.com/goravel/framework/grpc"
    29  	"github.com/goravel/framework/hash"
    30  	"github.com/goravel/framework/http"
    31  	"github.com/goravel/framework/log"
    32  	"github.com/goravel/framework/mail"
    33  	"github.com/goravel/framework/queue"
    34  	"github.com/goravel/framework/schedule"
    35  	"github.com/goravel/framework/support/file"
    36  	"github.com/goravel/framework/validation"
    37  )
    38  
    39  type ApplicationTestSuite struct {
    40  	suite.Suite
    41  	app *Application
    42  }
    43  
    44  func TestApplicationTestSuite(t *testing.T) {
    45  	assert.Nil(t, file.Create(".env", "APP_KEY=12345678901234567890123456789012"))
    46  
    47  	suite.Run(t, new(ApplicationTestSuite))
    48  
    49  	assert.Nil(t, file.Remove(".env"))
    50  }
    51  
    52  func (s *ApplicationTestSuite) SetupTest() {
    53  	s.app = &Application{
    54  		Container:     NewContainer(),
    55  		publishes:     make(map[string]map[string]string),
    56  		publishGroups: make(map[string]map[string]string),
    57  	}
    58  	App = s.app
    59  }
    60  
    61  func (s *ApplicationTestSuite) TestPath() {
    62  	s.Equal(filepath.Join("app", "goravel.go"), s.app.Path("goravel.go"))
    63  }
    64  
    65  func (s *ApplicationTestSuite) TestBasePath() {
    66  	s.Equal("goravel.go", s.app.BasePath("goravel.go"))
    67  }
    68  
    69  func (s *ApplicationTestSuite) TestConfigPath() {
    70  	s.Equal(filepath.Join("config", "goravel.go"), s.app.ConfigPath("goravel.go"))
    71  }
    72  
    73  func (s *ApplicationTestSuite) TestDatabasePath() {
    74  	s.Equal(filepath.Join("database", "goravel.go"), s.app.DatabasePath("goravel.go"))
    75  }
    76  
    77  func (s *ApplicationTestSuite) TestStoragePath() {
    78  	s.Equal(filepath.Join("storage", "goravel.go"), s.app.StoragePath("goravel.go"))
    79  }
    80  
    81  func (s *ApplicationTestSuite) TestPublicPath() {
    82  	s.Equal(filepath.Join("public", "goravel.go"), s.app.PublicPath("goravel.go"))
    83  }
    84  
    85  func (s *ApplicationTestSuite) TestPublishes() {
    86  	s.app.Publishes("github.com/goravel/sms", map[string]string{
    87  		"config.go": "config.go",
    88  	})
    89  	s.Equal(1, len(s.app.publishes["github.com/goravel/sms"]))
    90  	s.Equal(0, len(s.app.publishGroups))
    91  
    92  	s.app.Publishes("github.com/goravel/sms", map[string]string{
    93  		"config.go":  "config1.go",
    94  		"config1.go": "config1.go",
    95  	}, "public", "private")
    96  	s.Equal(2, len(s.app.publishes["github.com/goravel/sms"]))
    97  	s.Equal("config1.go", s.app.publishes["github.com/goravel/sms"]["config.go"])
    98  	s.Equal(2, len(s.app.publishGroups["public"]))
    99  	s.Equal("config1.go", s.app.publishGroups["public"]["config.go"])
   100  	s.Equal(2, len(s.app.publishGroups["private"]))
   101  }
   102  
   103  func (s *ApplicationTestSuite) TestAddPublishGroup() {
   104  	s.app.addPublishGroup("public", map[string]string{
   105  		"config.go": "config.go",
   106  	})
   107  	s.Equal(1, len(s.app.publishGroups["public"]))
   108  
   109  	s.app.addPublishGroup("public", map[string]string{
   110  		"config.go":  "config1.go",
   111  		"config1.go": "config1.go",
   112  	})
   113  	s.Equal(2, len(s.app.publishGroups["public"]))
   114  	s.Equal("config1.go", s.app.publishGroups["public"]["config.go"])
   115  }
   116  
   117  func (s *ApplicationTestSuite) TestMakeArtisan() {
   118  	serviceProvider := &console.ServiceProvider{}
   119  	serviceProvider.Register(s.app)
   120  
   121  	s.NotNil(s.app.MakeArtisan())
   122  }
   123  
   124  func (s *ApplicationTestSuite) TestMakeAuth() {
   125  	mockConfig := &configmocks.Config{}
   126  	mockConfig.On("GetString", "auth.defaults.guard").Return("user").Once()
   127  
   128  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   129  		return mockConfig, nil
   130  	})
   131  	s.app.Singleton(cache.Binding, func(app foundation.Application) (any, error) {
   132  		return &cachemocks.Cache{}, nil
   133  	})
   134  	s.app.Singleton(database.BindingOrm, func(app foundation.Application) (any, error) {
   135  		return &ormmocks.Orm{}, nil
   136  	})
   137  
   138  	serviceProvider := &auth.ServiceProvider{}
   139  	serviceProvider.Register(s.app)
   140  
   141  	s.NotNil(s.app.MakeAuth())
   142  	mockConfig.AssertExpectations(s.T())
   143  }
   144  
   145  func (s *ApplicationTestSuite) TestMakeCache() {
   146  	mockConfig := &configmocks.Config{}
   147  	mockConfig.On("GetString", "cache.default").Return("memory").Once()
   148  	mockConfig.On("GetString", "cache.stores.memory.driver").Return("memory").Once()
   149  	mockConfig.On("GetString", "cache.prefix").Return("goravel").Once()
   150  
   151  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   152  		return mockConfig, nil
   153  	})
   154  	s.app.Singleton(log.Binding, func(app foundation.Application) (any, error) {
   155  		return &logmocks.Log{}, nil
   156  	})
   157  
   158  	serviceProvider := &cache.ServiceProvider{}
   159  	serviceProvider.Register(s.app)
   160  
   161  	s.NotNil(s.app.MakeCache())
   162  	mockConfig.AssertExpectations(s.T())
   163  }
   164  
   165  func (s *ApplicationTestSuite) TestMakeConfig() {
   166  	serviceProvider := &config.ServiceProvider{}
   167  	serviceProvider.Register(s.app)
   168  
   169  	s.NotNil(s.app.MakeConfig())
   170  }
   171  
   172  func (s *ApplicationTestSuite) TestMakeCrypt() {
   173  	mockConfig := &configmocks.Config{}
   174  	mockConfig.On("GetString", "app.key").Return("12345678901234567890123456789012").Once()
   175  
   176  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   177  		return mockConfig, nil
   178  	})
   179  
   180  	serviceProvider := &crypt.ServiceProvider{}
   181  	serviceProvider.Register(s.app)
   182  
   183  	s.NotNil(s.app.MakeCrypt())
   184  	mockConfig.AssertExpectations(s.T())
   185  }
   186  
   187  func (s *ApplicationTestSuite) TestMakeEvent() {
   188  	s.app.Singleton(queue.Binding, func(app foundation.Application) (any, error) {
   189  		return &queuemocks.Queue{}, nil
   190  	})
   191  
   192  	serviceProvider := &event.ServiceProvider{}
   193  	serviceProvider.Register(s.app)
   194  
   195  	s.NotNil(s.app.MakeEvent())
   196  }
   197  
   198  func (s *ApplicationTestSuite) TestMakeGate() {
   199  	serviceProvider := &auth.ServiceProvider{}
   200  	serviceProvider.Register(s.app)
   201  
   202  	s.NotNil(s.app.MakeGate())
   203  }
   204  
   205  func (s *ApplicationTestSuite) TestMakeGrpc() {
   206  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   207  		return &configmocks.Config{}, nil
   208  	})
   209  
   210  	serviceProvider := &grpc.ServiceProvider{}
   211  	serviceProvider.Register(s.app)
   212  
   213  	s.NotNil(s.app.MakeGrpc())
   214  }
   215  
   216  func (s *ApplicationTestSuite) TestMakeHash() {
   217  	mockConfig := &configmocks.Config{}
   218  	mockConfig.On("GetString", "hashing.driver", "argon2id").Return("argon2id").Once()
   219  	mockConfig.On("GetInt", "hashing.argon2id.time", 4).Return(4).Once()
   220  	mockConfig.On("GetInt", "hashing.argon2id.memory", 65536).Return(65536).Once()
   221  	mockConfig.On("GetInt", "hashing.argon2id.threads", 1).Return(1).Once()
   222  
   223  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   224  		return mockConfig, nil
   225  	})
   226  
   227  	serviceProvider := &hash.ServiceProvider{}
   228  	serviceProvider.Register(s.app)
   229  
   230  	s.NotNil(s.app.MakeHash())
   231  	mockConfig.AssertExpectations(s.T())
   232  }
   233  
   234  func (s *ApplicationTestSuite) TestMakeLog() {
   235  	serviceProvider := &log.ServiceProvider{}
   236  	serviceProvider.Register(s.app)
   237  
   238  	s.NotNil(s.app.MakeLog())
   239  }
   240  
   241  func (s *ApplicationTestSuite) TestMakeMail() {
   242  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   243  		return &configmocks.Config{}, nil
   244  	})
   245  	s.app.Singleton(queue.Binding, func(app foundation.Application) (any, error) {
   246  		return &queuemocks.Queue{}, nil
   247  	})
   248  
   249  	serviceProvider := &mail.ServiceProvider{}
   250  	serviceProvider.Register(s.app)
   251  
   252  	s.NotNil(s.app.MakeMail())
   253  }
   254  
   255  func (s *ApplicationTestSuite) TestMakeOrm() {
   256  	if testing.Short() {
   257  		s.T().Skip("Skipping tests of using docker")
   258  	}
   259  
   260  	mysqlDocker := gorm.NewMysqlDocker()
   261  	pool, resource, _, err := mysqlDocker.New()
   262  	s.Nil(err)
   263  
   264  	mockConfig := &configmocks.Config{}
   265  	mockConfig.On("GetString", "database.default").Return("mysql").Once()
   266  	mockConfig.On("Get", "database.connections.mysql.read").Return(nil).Once()
   267  	mockConfig.On("Get", "database.connections.mysql.write").Return(nil).Once()
   268  	mockConfig.On("GetString", "database.connections.mysql.driver").Return(orm.DriverMysql.String()).Twice()
   269  	mockConfig.On("GetString", "database.connections.mysql.charset").Return("utf8mb4").Once()
   270  	mockConfig.On("GetString", "database.connections.mysql.loc").Return("Local").Once()
   271  	mockConfig.On("GetString", "database.connections.mysql.database").Return("mysql").Once()
   272  	mockConfig.On("GetString", "database.connections.mysql.host").Return("localhost").Once()
   273  	mockConfig.On("GetString", "database.connections.mysql.username").Return(gorm.DbUser).Once()
   274  	mockConfig.On("GetString", "database.connections.mysql.password").Return(gorm.DbPassword).Once()
   275  	mockConfig.On("GetString", "database.connections.mysql.prefix").Return("").Once()
   276  	mockConfig.On("GetInt", "database.connections.mysql.port").Return(mysqlDocker.Port).Once()
   277  	mockConfig.On("GetBool", "database.connections.mysql.singular").Return(true).Once()
   278  	mockConfig.On("GetBool", "app.debug").Return(true).Once()
   279  	mockConfig.On("GetInt", "database.pool.max_idle_conns", 10).Return(10)
   280  	mockConfig.On("GetInt", "database.pool.max_open_conns", 100).Return(100)
   281  	mockConfig.On("GetInt", "database.pool.conn_max_idletime", 3600).Return(3600)
   282  	mockConfig.On("GetInt", "database.pool.conn_max_lifetime", 3600).Return(3600)
   283  
   284  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   285  		return mockConfig, nil
   286  	})
   287  
   288  	serviceProvider := &database.ServiceProvider{}
   289  	serviceProvider.Register(s.app)
   290  
   291  	s.NotNil(s.app.MakeOrm())
   292  	s.Nil(pool.Purge(resource))
   293  	mockConfig.AssertExpectations(s.T())
   294  }
   295  
   296  func (s *ApplicationTestSuite) TestMakeQueue() {
   297  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   298  		return &configmocks.Config{}, nil
   299  	})
   300  
   301  	serviceProvider := &queue.ServiceProvider{}
   302  	serviceProvider.Register(s.app)
   303  
   304  	s.NotNil(s.app.MakeQueue())
   305  }
   306  
   307  func (s *ApplicationTestSuite) TestMakeRateLimiter() {
   308  	serviceProvider := &http.ServiceProvider{}
   309  	serviceProvider.Register(s.app)
   310  
   311  	s.NotNil(s.app.MakeRateLimiter())
   312  }
   313  
   314  func (s *ApplicationTestSuite) TestMakeRoute() {
   315  	mockConfig := &configmocks.Config{}
   316  
   317  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   318  		return mockConfig, nil
   319  	})
   320  
   321  	mockRoute := &routemocks.Route{}
   322  	s.app.Singleton("goravel.route", func(app foundation.Application) (any, error) {
   323  		return mockRoute, nil
   324  	})
   325  
   326  	s.NotNil(s.app.MakeRoute())
   327  	mockConfig.AssertExpectations(s.T())
   328  }
   329  
   330  func (s *ApplicationTestSuite) TestMakeSchedule() {
   331  	s.app.Singleton(console.Binding, func(app foundation.Application) (any, error) {
   332  		return &consolemocks.Artisan{}, nil
   333  	})
   334  	s.app.Singleton(log.Binding, func(app foundation.Application) (any, error) {
   335  		return &logmocks.Log{}, nil
   336  	})
   337  
   338  	serviceProvider := &schedule.ServiceProvider{}
   339  	serviceProvider.Register(s.app)
   340  
   341  	s.NotNil(s.app.MakeSchedule())
   342  }
   343  
   344  func (s *ApplicationTestSuite) TestMakeStorage() {
   345  	mockConfig := &configmocks.Config{}
   346  	mockConfig.On("GetString", "filesystems.default").Return("local").Once()
   347  	mockConfig.On("GetString", "filesystems.disks.local.driver").Return("local").Once()
   348  	mockConfig.On("GetString", "filesystems.disks.local.root").Return("").Once()
   349  	mockConfig.On("GetString", "filesystems.disks.local.url").Return("").Once()
   350  
   351  	s.app.Singleton(config.Binding, func(app foundation.Application) (any, error) {
   352  		return mockConfig, nil
   353  	})
   354  
   355  	serviceProvider := &filesystem.ServiceProvider{}
   356  	serviceProvider.Register(s.app)
   357  
   358  	s.NotNil(s.app.MakeStorage())
   359  	mockConfig.AssertExpectations(s.T())
   360  }
   361  
   362  func (s *ApplicationTestSuite) TestMakeValidation() {
   363  	serviceProvider := &validation.ServiceProvider{}
   364  	serviceProvider.Register(s.app)
   365  
   366  	s.NotNil(s.app.MakeValidation())
   367  }