// InitializeEnvironment creates new transaction for the test
func (env *Environment) InitializeEnvironment() error {
var err error
_, file := filepath.Split(env.testFileName)
env.dbFile, err = ioutil.TempFile(os.TempDir(), file)
if err != nil {
return fmt.Errorf("Failed to create a temporary file in %s: %s", os.TempDir(), err.Error())
}
env.dbConnection, err = newDBConnection(env.dbFile.Name())
if err != nil {
return fmt.Errorf("Failed to connect to database: %s", err.Error())
}
env.Environment = gohan_otto.NewEnvironment(env.dbConnection, &middleware.FakeIdentity{}, 30*time.Second)
env.SetUp()
env.addTestingAPI()
script, err := env.VM.Compile(env.testFileName, env.testSource)
if err != nil {
return fmt.Errorf("Failed to compile the file '%s': %s", env.testFileName, err.Error())
}
env.VM.Run(script)
err = env.loadSchemas()
if err != nil {
schema.ClearManager()
return fmt.Errorf("Failed to load schema for '%s': %s", env.testFileName, err.Error())
}
err = db.InitDBWithSchemas("sqlite3", env.dbFile.Name(), true, false)
if err != nil {
schema.ClearManager()
return fmt.Errorf("Failed to init DB: %s", err.Error())
}
return nil
}
func newEnvironmentWithExtension(extension *schema.Extension) (env extension.Environment) {
timelimit := time.Duration(1) * time.Second
extensions := []*schema.Extension{extension}
env = otto.NewEnvironment("db_test",
testDB, &middleware.FakeIdentity{}, timelimit)
Expect(env.LoadExtensionsForPath(extensions, "test_path")).To(Succeed())
return
}
func (server *Server) newEnvironment(name string) extension.Environment {
envs := []extension.Environment{}
timelimit := time.Duration(server.timelimit) * time.Second
for _, extension := range server.extensions {
switch extension {
case "javascript":
envs = append(envs, otto.NewEnvironment(name, server.db, server.keystoneIdentity, timelimit))
case "gohanscript":
envs = append(envs, gohanscript.NewEnvironment(timelimit))
case "go":
envs = append(envs, golang.NewEnvironment())
}
}
return extension.NewEnvironment(envs)
}
"github.com/cloudwan/gohan/server/middleware"
)
var _ = Describe("Environment manager", func() {
const (
schemaID1 = "Wormtongue"
schemaID2 = "Dumbledore"
)
var (
env1 extension.Environment
env2 extension.Environment
manager *extension.Manager
)
BeforeEach(func() {
env1 = otto.NewEnvironment(testDB1, &middleware.FakeIdentity{})
env2 = otto.NewEnvironment(testDB2, &middleware.FakeIdentity{})
})
JustBeforeEach(func() {
manager = extension.GetManager()
Expect(manager.RegisterEnvironment(schemaID1, env1)).To(Succeed())
})
AfterEach(func() {
extension.ClearManager()
})
Describe("Registering environments", func() {
Context("When it isn't registered", func() {
It("Should register it", func() {
"id": "test_extension",
"code": `
gohan_register_handler("test_event", function(context){
var tx = context.transaction;
context.resp = gohan_db_state_fetch(
tx,
"test",
"resource_id",
"tenant0"
);
});`,
"path": ".*",
})
Expect(err).ToNot(HaveOccurred())
extensions := []*schema.Extension{extension}
env := otto.NewEnvironment(testDB, &middleware.FakeIdentity{}, timelimit)
Expect(env.LoadExtensionsForPath(extensions, "test_path")).To(Succeed())
manager := schema.GetManager()
s, ok := manager.Schema("test")
Expect(ok).To(BeTrue())
var fakeTx = new(mocks.Transaction)
fakeTx.On(
"StateFetch", s, "resource_id", []string{"tenant0"},
).Return(
transaction.ResourceState{
ConfigVersion: 30,
StateVersion: 29,
Error: "e",
State: "s",
"github.com/cloudwan/gohan/server/middleware"
)
var _ = Describe("Environment manager", func() {
const (
schemaID1 = "Wormtongue"
schemaID2 = "Dumbledore"
)
var (
env1 extension.Environment
env2 extension.Environment
manager *extension.Manager
)
BeforeEach(func() {
env1 = otto.NewEnvironment("extension_test1",
testDB1, &middleware.FakeIdentity{}, time.Second)
env2 = otto.NewEnvironment("extension_test2",
testDB2, &middleware.FakeIdentity{}, time.Second)
})
JustBeforeEach(func() {
manager = extension.GetManager()
Expect(manager.RegisterEnvironment(schemaID1, env1)).To(Succeed())
})
AfterEach(func() {
extension.ClearManager()
})
Describe("Registering environments", func() {
Context("When it isn't registered", func() {
"code": `gohan_register_handler("test_event", function(context) {});`,
"path": ".*",
})
Expect(err).ToNot(HaveOccurred())
goodExtension.URL = "good_extension.js"
badExtension, err := schema.NewExtension(map[string]interface{}{
"id": "bad_extension",
"code": `gohan_register_handler("test_event", function(context {});`,
"path": ".*",
})
Expect(err).ToNot(HaveOccurred())
badExtension.URL = "bad_extension.js"
extensions := []*schema.Extension{goodExtension, badExtension}
env := otto.NewEnvironment(testDB, &middleware.FakeIdentity{})
err = env.LoadExtensionsForPath(extensions, "test_path")
Expect(err).To(HaveOccurred(), "Expected compilation errors.")
pattern := regexp.MustCompile(`^(?P<file>[^:]+).*Line\s(?P<line>\d+).*`)
match := pattern.FindStringSubmatch(err.Error())
Expect(len(match)).To(Equal(3))
groups := make(map[string]string)
for i, name := range pattern.SubexpNames() {
groups[name] = match[i]
}
Expect(groups).To(HaveKeyWithValue("file", "bad_extension.js"))
Expect(groups).To(HaveKeyWithValue("line", "1"))
})
func newEnvironment(dataStore db.DB, identity middleware.IdentityService, timelimit int) extension.Environment {
return otto.NewEnvironment(dataStore, identity, time.Duration(timelimit)*time.Second)
}
func newEnvironment(dataStore db.DB, identity middleware.IdentityService) extension.Environment {
return otto.NewEnvironment(dataStore, identity)
}
"github.com/cloudwan/gohan/server/middleware"
)
var _ = Describe("Environment manager", func() {
const (
schemaID1 = "Wormtongue"
schemaID2 = "Dumbledore"
)
var (
env1 extension.Environment
env2 extension.Environment
manager *extension.Manager
)
BeforeEach(func() {
env1 = otto.NewEnvironment(testDB1, &middleware.FakeIdentity{}, time.Second)
env2 = otto.NewEnvironment(testDB2, &middleware.FakeIdentity{}, time.Second)
})
JustBeforeEach(func() {
manager = extension.GetManager()
Expect(manager.RegisterEnvironment(schemaID1, env1)).To(Succeed())
})
AfterEach(func() {
extension.ClearManager()
})
Describe("Registering environments", func() {
Context("When it isn't registered", func() {
It("Should register it", func() {
"code": `gohan_register_handler("test_event", function(context) {});`,
"path": ".*",
})
Expect(err).ToNot(HaveOccurred())
goodExtension.URL = "good_extension.js"
badExtension, err := schema.NewExtension(map[string]interface{}{
"id": "bad_extension",
"code": `gohan_register_handler("test_event", function(context {});`,
"path": ".*",
})
Expect(err).ToNot(HaveOccurred())
badExtension.URL = "bad_extension.js"
extensions := []*schema.Extension{goodExtension, badExtension}
env := otto.NewEnvironment(testDB, &middleware.FakeIdentity{}, timelimit)
err = env.LoadExtensionsForPath(extensions, "test_path")
Expect(err).To(HaveOccurred(), "Expected compilation errors.")
pattern := regexp.MustCompile(`^(?P<file>[^:]+).*Line\s(?P<line>\d+).*`)
match := pattern.FindStringSubmatch(err.Error())
Expect(len(match)).To(Equal(3))
groups := make(map[string]string)
for i, name := range pattern.SubexpNames() {
groups[name] = match[i]
}
Expect(groups).To(HaveKeyWithValue("file", "bad_extension.js"))
Expect(groups).To(HaveKeyWithValue("line", "1"))
})
