func (env *Environment) addTestingAPI() {
builtins := map[string]interface{}{
"Fail": func(call otto.FunctionCall) otto.Value {
if len(call.ArgumentList) == 0 {
panic(fmt.Errorf("Fail!"))
}
if !call.ArgumentList[0].IsString() {
panic(fmt.Errorf("Invalid call to 'Fail': format string expected first"))
}
format, _ := call.ArgumentList[0].ToString()
args := []interface{}{}
for _, value := range call.ArgumentList[1:] {
args = append(args, gohan_otto.ConvertOttoToGo(value))
}
panic(fmt.Errorf(format, args...))
},
"MockTransaction": func(call otto.FunctionCall) otto.Value {
newTransaction := false
if len(call.ArgumentList) > 1 {
panic("Wrong number of arguments in MockTransaction call.")
} else if len(call.ArgumentList) == 1 {
rawNewTransaction, _ := call.Argument(0).Export()
newTransaction = rawNewTransaction.(bool)
}
transactionValue, _ := call.Otto.ToValue(env.getTransaction(newTransaction))
return transactionValue
},
"CommitMockTransaction": func(call otto.FunctionCall) otto.Value {
tx := env.getTransaction(false)
tx.Commit()
tx.Close()
return otto.Value{}
},
"MockPolicy": func(call otto.FunctionCall) otto.Value {
policyValue, _ := call.Otto.ToValue(schema.NewEmptyPolicy())
return policyValue
},
"MockAuthorization": func(call otto.FunctionCall) otto.Value {
authorizationValue, _ := call.Otto.ToValue(schema.NewAuthorization("", "", "", []string{}, []*schema.Catalog{}))
return authorizationValue
},
}
for name, object := range builtins {
env.VM.Set(name, object)
}
// NOTE: There is no way to return error back to Otto after calling a Go
// function, so the following function has to be written in pure JavaScript.
env.VM.Otto.Run(`function GohanTrigger(event, context) { gohan_handle_event(event, context); }`)
env.mockFunction("gohan_http")
env.mockFunction("gohan_raw_http")
env.mockFunction("gohan_db_transaction")
env.mockFunction("gohan_config")
}
func authorization(w http.ResponseWriter, r *http.Request, action, path string, s *schema.Schema, auth schema.Authorization) (*schema.Policy, *schema.Role) {
manager := schema.GetManager()
log.Debug("[authorization*] %s %v", action, auth)
if auth == nil {
return schema.NewEmptyPolicy(), nil
}
policy, role := manager.PolicyValidate(action, path, auth)
if policy == nil {
log.Debug("No maching policy: %s %s", action, path)
return nil, nil
}
return policy, role
}