Exemple #1
0
func Test_InjectorSetParent(t *testing.T) {
	injector := inject.New()
	injector.MapTo("another dep", (*SpecialString)(nil))

	injector2 := inject.New()
	injector2.SetParent(injector)

	expect(t, injector2.Get(inject.InterfaceOf((*SpecialString)(nil))).IsValid(), true)
}
//结论:Apply方法是用于对struct的字段进行注入,参数为指向底层类型为结构体的指针。
//可注入的前提是:字段必须是导出的(也即字段名以大写字母开头),并且此字段的tag设置为`inject`
func main() {
	s := TestStruct{}
	inj := inject.New()
	inj.Map("陈一回")
	inj.MapTo("男", (*SpecialString)(nil))
	inj2 := inject.New()
	inj2.Map(20)
	inj.SetParent(inj2)
	inj.Apply(&s)
	fmt.Println("s.Name =", s.Name)
	fmt.Println("s.Gender =", s.Gender)
	fmt.Println("s.Age =", s.Age)
	fmt.Println("s.Nick =", s.Nick)
	fmt.Println("s.uid =", s.uid)
}
Exemple #3
0
func (ae *App) MakeHandler(handlers ...interface{}) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		child := inject.New()
		child.SetParent(ae.Injector)
		child.MapTo(w, (*http.ResponseWriter)(nil))
		child.Map(r)
	handlerLoop:
		for _, reqProcessor := range handlers {
			result, err := child.Invoke(reqProcessor)
			if err != nil {
				w.WriteHeader(http.StatusInternalServerError)
				fmt.Fprintf(os.Stderr, "error in url %v: %v\n", r.URL, err)
				return
			}

			if len(result) == 0 {
				continue
			} else {
				valAsInterface := result[0].Interface()
				if resp, ok := valAsInterface.(HTTPResponse); ok {
					err := resp.Render(w)
					if err != nil {
						w.WriteHeader(http.StatusInternalServerError)
						fmt.Fprintln(os.Stderr, "error: %v", err)
					}
					if reflect.TypeOf(valAsInterface) != reflect.TypeOf(ChainHttpResponse{}) {
						break handlerLoop
					}
				}
			}
		}
	}
}
Exemple #4
0
func TestInjectImplementors(t *testing.T) {
	injector := inject.New()
	g := &Greeter{"Jeremy"}
	injector.Map(g)

	expect(t, injector.Get(inject.InterfaceOf((*fmt.Stringer)(nil))).IsValid(), true)
}
Exemple #5
0
func wrap(f interface{}) func(*cli.Context) {
	return func(ctx *cli.Context) {
		if ctx.GlobalBool("debug") {
			log.SetOutputLevel(log.Ldebug)
		}

		sockPath := filepath.Join(GOSUV_HOME, "gosuv.sock")
		if err := testConnection("unix", sockPath); err != nil {
			log.Fatal(err)
		}

		conn, err := connect(ctx)
		if err != nil {
			log.Fatal(err)
		}
		defer conn.Close()
		programClient := pb.NewProgramClient(conn)
		gosuvClient := pb.NewGoSuvClient(conn)

		inj := inject.New()
		inj.Map(programClient)
		inj.Map(gosuvClient)
		inj.Map(ctx)
		inj.Invoke(f)
	}
}
Exemple #6
0
func Test_InjectorInvoke(t *testing.T) {
	injector := inject.New()
	expect(t, injector == nil, false)

	dep := "some dependency"
	injector.Map(dep)
	dep2 := "another dep"
	injector.MapTo(dep2, (*SpecialString)(nil))
	dep3 := make(chan *SpecialString)
	dep4 := make(chan *SpecialString)
	typRecv := reflect.ChanOf(reflect.RecvDir, reflect.TypeOf(dep3).Elem())
	typSend := reflect.ChanOf(reflect.SendDir, reflect.TypeOf(dep4).Elem())
	injector.Set(typRecv, reflect.ValueOf(dep3))
	injector.Set(typSend, reflect.ValueOf(dep4))

	_, err := injector.Invoke(func(d1 string, d2 SpecialString, d3 <-chan *SpecialString, d4 chan<- *SpecialString) {
		expect(t, d1, dep)
		expect(t, d2, dep2)
		expect(t, reflect.TypeOf(d3).Elem(), reflect.TypeOf(dep3).Elem())
		expect(t, reflect.TypeOf(d4).Elem(), reflect.TypeOf(dep4).Elem())
		expect(t, reflect.TypeOf(d3).ChanDir(), reflect.RecvDir)
		expect(t, reflect.TypeOf(d4).ChanDir(), reflect.SendDir)
	})

	expect(t, err, nil)
}
Exemple #7
0
func Injs(args ...interface{}) Injector {
	inj := inject.New()
	for _, v := range args {
		inj.Map(v)
	}
	return inj
}
Exemple #8
0
// 连接函数 返回error 结束 下一次传递
func JoinBy(t interface{}, fs ...interface{}) interface{} {

	val := reflect.ValueOf(t)
	if val.Kind() != reflect.Func {
		return nil
	}

	for k, v := range fs {
		c := toCaller(v)
		if c == nil {
			return nil
		}
		fs[k] = c
	}

	typ := val.Type()
	r := reflect.MakeFunc(typ, func(args []reflect.Value) (results []reflect.Value) {
		inj := inject.New()
		for _, v := range args {
			inj.Set(v.Type(), v)
		}
		inj = SliceFunc(inj, fs)
		for i := 0; i != typ.NumOut(); i++ {
			results = append(results, inj.Get(typ.Out(i)))
		}
		return
	})
	return r.Interface()
}
Exemple #9
0
func Test_Static_Options_Logging(t *testing.T) {
	response := httptest.NewRecorder()

	var buffer bytes.Buffer
	m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(&buffer, "[martini] ", 0)}
	m.Map(m.logger)
	m.Map(defaultReturnHandler())

	opt := StaticOptions{}
	m.Use(Static(currentRoot, opt))

	req, err := http.NewRequest("GET", "http://localhost:3000/martini.go", nil)
	if err != nil {
		t.Error(err)
	}

	m.ServeHTTP(response, req)
	expect(t, response.Code, http.StatusOK)
	expect(t, buffer.String(), "[martini] [Static] Serving /martini.go\n")

	// Now without logging
	m.Handlers()
	buffer.Reset()

	// This should disable logging
	opt.SkipLogging = true
	m.Use(Static(currentRoot, opt))

	m.ServeHTTP(response, req)
	expect(t, response.Code, http.StatusOK)
	expect(t, buffer.String(), "")
}
Exemple #10
0
// create new helper, this object will be used for globar service for martini middleware
func New() *MartiniHelper {
	this := &MartiniHelper{inject.New()}
	retHandler := martini.New().Get(reflect.TypeOf(martini.ReturnHandler(nil))).Interface()
	// retHandler := martini.defaultReturnHandler()
	this.Map(retHandler)
	return this
}
Exemple #11
0
func (e *eventManager) Trigger(eventName EventType, data map[string]interface{}) {
	e.Lock()
	defer e.Unlock()
	handlers, ok := e.events[eventName]
	wildcardHandlers, wok := e.events[AllEvents]
	if !ok && !wok {
		return
	}

	event := Event{eventName, data}

	c := inject.New()
	c.SetParent(e.injector)
	c.Map(event)

	if ok {
		for _, handler := range handlers {
			c.Invoke(handler.Interface())
		}
	}

	if wok {
		for _, handler := range wildcardHandlers {
			c.Invoke(handler.Interface())
		}
	}
}
Exemple #12
0
func NewApp() *App {
	return &App{
		TemplateFuncs:  make(map[string]interface{}),
		TemplateCache:  make(map[string]*template.Template),
		CacheTemplates: true,
		Injector:       inject.New(),
	}
}
Exemple #13
0
func (m *Martini) createContext(res http.ResponseWriter, req *http.Request) *context {
	c := &context{inject.New(), m.handlers, m.action, NewResponseWriter(res), 0}
	c.SetParent(m)
	c.MapTo(c, (*Context)(nil))
	c.MapTo(c.rw, (*http.ResponseWriter)(nil))
	c.Map(req)
	return c
}
Exemple #14
0
func Test_InjectorGet(t *testing.T) {
	injector := inject.New()

	injector.Map("some dependency")

	expect(t, injector.Get(reflect.TypeOf("string")).IsValid(), true)
	expect(t, injector.Get(reflect.TypeOf(11)).IsValid(), false)
}
Exemple #15
0
func (w *WorkerConfig) worker(id string) {
	injector := inject.New()
	injector.SetParent(w.Injector)
	for msg := range w.workQueue {
		if msg.die {
			break
		}

		job := msg.job
		typ, ok := w.workerMapping[msg.job.Type]
		if !ok {
			err := UnknownWorkerError{job.Type}
			w.scheduleRetry(job, err, true)
			continue
		}

		w.trackJobStart(job, id)

		// wrap Perform() in a function so that we can recover from panics
		var err error
		var worker interface{}
		func() {
			defer func() {
				if r := recover(); r != nil {
					err = newPanicError(r)
				}
			}()
			workerVal := reflect.New(typ)
			worker = workerVal.Interface()
			if err = json.Unmarshal(*job.Args, worker); err != nil {
				return
			}
			injector.Map(job)
			if err = injector.Apply(worker); err != nil {
				return
			}
			var res []reflect.Value
			res, err = injector.Invoke(workerVal.MethodByName("Perform").Interface())
			if err != nil {
				return
			}
			if resErr := res[0].Interface(); resErr != nil && resErr.(error) != nil {
				err = resErr.(error)
			}
		}()
		if err != nil {
			report := true
			if checker, ok := worker.(ReportableErrorChecker); ok {
				report = checker.ReportableError(err)
			}
			w.scheduleRetry(job, err, report)
		}
		w.trackJobFinish(job, id, err == nil)
	}
	w.done.Done()
}
Exemple #16
0
func main() {
	inj := inject.New()
	inj.Map("Xargin")
	inj.MapTo("男", (*SpecialString)(nil))
	//inj.MapTo("男", (*SpecialString)(nil))
	//inj.MapTo(10, (*MyInt)(nil))
	inj.MapTo(10, (*MyInt)(nil))
	inj.Map(1000)
	inj.Invoke(say)
}
Exemple #17
0
func NewPacketContext(pkt *Packet, ses *Session) IPacketContext {
	c := &packetContext{
		Injector: inject.New(),
		index:    0,
	}
	c.Map(pkt)
	c.Map(ses)
	c.MapTo(c, (*IPacketContext)(nil))

	return c
}
Exemple #18
0
func Test_InjectorApply(t *testing.T) {
	injector := inject.New()

	injector.Map("a dep").MapTo("another dep", (*SpecialString)(nil))

	s := TestStruct{}
	err := injector.Apply(&s)
	expect(t, err, nil)

	expect(t, s.Dep1, "a dep")
	expect(t, s.Dep2, "another dep")
}
Exemple #19
0
func main() {
	ij := inject.New()
	ij.Map(20)
	ij.MapTo("Good Morning", (*MyString)(nil))

	ij1 := inject.New()
	ij1.Map("Steven")

	ij.SetParent(ij1)
	ij.Invoke(Hello)

	fmt.Println(inject.InterfaceOf((*MyString)(nil)))

	team := MyStruct{}
	ij2 := inject.New()
	ij2.Map("Liverpool LFC")
	ij2.MapTo("England", (*MyString)(nil))
	ij2.Apply(&team)

	fmt.Printf("TEAM NAME: %s \n", team.Name)
	fmt.Printf("TEAM TEAM: %s \n", team.Team)
	fmt.Printf("TEAM LOCATION: %s \n", team.Location)
}
Exemple #20
0
func NewSession() *Session {
	env := make(map[string]string)
	for _, key := range []string{"PATH"} {
		env[key] = os.Getenv(key)
	}
	s := &Session{
		inj:    inject.New(),
		alias:  make(map[string][]string),
		dir:    Dir(""),
		Stdout: os.Stdout,
		Stderr: os.Stderr,
		Env:    env,
	}
	return s
}
Exemple #21
0
func TestEventHandler(t *testing.T) {
	invoker := inject.New()
	manager := NewEventManager(invoker)

	test := false
	manager.Bind(TestEvent, func(event Event) {
		test = true
	})

	manager.Trigger(TestEvent, nil)

	if !test {
		t.Error("Failed to trigger event")
	}
}
// NewAction creates an empty action, ready to populate with views
func NewAction(name string, config ConfigValues) *Action {
	a := &Action{
		Injector: inject.New(),
		name:     name,
		views:    make(map[string]*View),
		items:    make([]*Item, 0),
	}

	// config
	if _, found := config["actionDefaultScript"]; !found {
		panic("you should specify 'actionDefaultScript' in the config")
	}
	defaultConfig := ConfigValues{
		"debug":      false,
		"autoUpdate": true,
	}
	for k, v := range config {
		defaultConfig[k] = v
	}
	a.Config = NewConfigDefaults(a.SupportPath(), defaultConfig)

	a.Cache = NewCache(a.CachePath())
	fd, err := os.OpenFile(path.Join(a.SupportPath(), "error.log"), os.O_APPEND|os.O_CREATE|os.O_WRONLY|os.O_SYNC, 0644)
	if err != nil {
		fd = os.Stderr
	}
	a.Logger = log.New(fd, "", 0)
	c := &Context{
		Action: a,
		Config: a.Config,
		Cache:  a.Cache,
		Logger: a.Logger,
	}
	a.context = c
	a.Map(c)

	data, err := ioutil.ReadFile(path.Join(a.ActionPath(), "Contents", "Info.plist"))
	if err != nil {
		a.Logger.Println(err)
		panic(err)
	}
	_, err = plist.Unmarshal(data, &a.info)
	if err != nil {
		a.Logger.Println(err)
		panic(err)
	}
	return a
}
func Test_InjectorInvoke(t *testing.T) {
	injector := inject.New()
	expect(t, injector == nil, false)

	dep := "some dependency"
	injector.Map(dep)
	dep2 := "another dep"
	injector.MapTo(dep2, (*SpecialString)(nil))

	_, err := injector.Invoke(func(d1 string, d2 SpecialString) {
		expect(t, d1, dep)
		expect(t, d2, dep2)
	})

	expect(t, err, nil)
}
Exemple #24
0
func (this *MartiniHelper) context(rwc *karambie.ResponseWriterContext, r *http.Request) martini.Context {
	if v, ok := rwc.GetOk(contextInstance); ok {
		return v.(martini.Context)
	} else {
		c := &context{inject.New()}
		c.SetParent(this)

		c.Map(rwc)
		c.MapTo(c, (*martini.Context)(nil))
		c.MapTo(martini.NewResponseWriter(rwc), (*http.ResponseWriter)(nil))
		c.Map(r)

		rwc.Set(contextInstance, c)
		return c
	}
}
Exemple #25
0
// NewInjector creates a TestInjector
func NewInjector(method string, body string) *Injector {
	var i Injector
	i.r, _ = http.NewRequest(method, "http://localhost/v1/", strings.NewReader(body))

	w := httptest.NewRecorder()

	enc := negotiator.JsonEncoder{PrettyPrint: false}
	cn := negotiator.NewContentNegotiator(enc, w)
	cn.AddEncoder(negotiator.MimeJSON, enc)

	i.Injector = inject.New()
	i.Injector.Map(i.r)
	i.Injector.MapTo(w, (*http.ResponseWriter)(nil))
	i.Injector.MapTo(cn, (*negotiator.Negotiator)(nil))

	return &i
}
Exemple #26
0
func NewWorkerConfig() *WorkerConfig {
	w := &WorkerConfig{
		Injector:      inject.New(),
		PollInterval:  defaultPollInterval,
		StopTimeout:   defaultStopTimeout,
		WorkerCount:   defaultWorkerCount,
		Queues:        QueueConfig{"default": 1},
		ReportError:   func(error, *Job) {},
		workerMapping: make(map[string]reflect.Type),
		workQueue:     make(chan message),
		work:          make(map[string]*Job),
	}
	w.RedisPool = redis.NewPool(func() (redis.Conn, error) {
		return redis.Dial("tcp", defaultRedisServer)
	}, w.WorkerCount+1)
	return w
}
Exemple #27
0
func TestInvalidHandler(t *testing.T) {
	failed := false
	defer func() {
		if err := recover(); err == InvalidHandler {
			failed = true
		}
	}()

	invoker := inject.New()
	manager := NewEventManager(invoker)

	manager.Bind(TestEvent, nil)

	if !failed {
		t.Error("Failed to trigger error")
	}
}
Exemple #28
0
func Test_InjectorSet(t *testing.T) {
	injector := inject.New()
	typ := reflect.TypeOf("string")
	typSend := reflect.ChanOf(reflect.SendDir, typ)
	typRecv := reflect.ChanOf(reflect.RecvDir, typ)

	// instantiating unidirectional channels is not possible using reflect
	// http://golang.org/src/pkg/reflect/value.go?s=60463:60504#L2064
	chanRecv := reflect.MakeChan(reflect.ChanOf(reflect.BothDir, typ), 0)
	chanSend := reflect.MakeChan(reflect.ChanOf(reflect.BothDir, typ), 0)

	injector.Set(typSend, chanSend)
	injector.Set(typRecv, chanRecv)

	expect(t, injector.Get(typSend).IsValid(), true)
	expect(t, injector.Get(typRecv).IsValid(), true)
	expect(t, injector.Get(chanSend.Type()).IsValid(), false)
}
Exemple #29
0
func Test_InjectorInvokeReturnValues(t *testing.T) {
	injector := inject.New()
	expect(t, injector == nil, false)

	dep := "some dependency"
	injector.Map(dep)
	dep2 := "another dep"
	injector.MapTo(dep2, (*SpecialString)(nil))

	result, err := injector.Invoke(func(d1 string, d2 SpecialString) string {
		expect(t, d1, dep)
		expect(t, d2, dep2)
		return "Hello world"
	})

	expect(t, result[0].String(), "Hello world")
	expect(t, err, nil)
}
Exemple #30
0
func Test_Static_Options_Expires(t *testing.T) {
	response := httptest.NewRecorder()

	var buffer bytes.Buffer
	m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(&buffer, "[martini] ", 0)}
	m.Map(m.logger)
	m.Map(defaultReturnHandler())

	// Serve current directory under /public
	m.Use(Static(currentRoot, StaticOptions{Expires: func() string { return "46" }}))

	// Check file content behaviour
	req, err := http.NewRequest("GET", "http://localhost:3000/martini.go", nil)
	if err != nil {
		t.Error(err)
	}

	m.ServeHTTP(response, req)
	expect(t, response.Header().Get("Expires"), "46")
}