Пример #1
0
func TestExtendNil(t *testing.T) {
	b := builder.Extend(FooBuilder, "Add", nil)
	_, ok := builder.Get(b, "X")
	if ok {
		t.Fatalf("key %v set unexpectedly", "Add")
	}
}
Пример #2
0
func TestDelete(t *testing.T) {
	b := builder.Delete(FooBuilder.X(1), "X")
	_, ok := builder.Get(b, "X")
	if ok {
		t.Fatalf("key %v not deleted", "X")
	}
}
Пример #3
0
func (b jsonBuilder) AddHrefLink(class string, href string) jsonBuilder {
	val, _ := builder.Get(b, "Hal")
	if val == nil {
		val = Hal{}
	}
	hal, _ := val.(Hal)
	hal.AddHrefLink(class, href)
	return builder.Set(b, "Hal", hal).(jsonBuilder)
}
Пример #4
0
func TestBuilder(t *testing.T) {
	b := FooBuilder.X(1).Y(2)
	assertInt(t, b, "X", 1)
	assertInt(t, b, "Y", 2)
	v, _ := builder.Get(b, "Z")
	if v != nil {
		t.Errorf("expected nil, got %v", v)
	}
}
Пример #5
0
func (b jsonBuilder) AddCustomField(name string, value interface{}) jsonBuilder {
	val, _ := builder.Get(b, "CustomFields")
	if val == nil {
		val = make(map[string]interface{})
	}
	fields, _ := val.(map[string]interface{})
	fields[name] = value
	return builder.Set(b, "CustomFields", fields).(jsonBuilder)
}
Пример #6
0
func (b FunctionBuilder) Params(key string, value interface{}) FunctionBuilder {
	var hash map[string]interface{}
	params, ok := builder.Get(b, "Params")
	if ok {
		hash = params.(map[string]interface{})
	} else {
		hash = make(map[string]interface{})
	}
	hash[key] = value
	return builder.Set(b, "Params", hash).(FunctionBuilder)
}
Пример #7
0
func assertInt(t *testing.T, b fooBuilder, key string, val int) {
	v, ok := builder.Get(b, key)
	if !ok {
		t.Errorf("key %v not set", key)
		return
	}
	i := v.(int)
	if i != val {
		t.Errorf("expected %d, got %d", val, i)
	}
	return
}
Пример #8
0
//############################################################################
func (b dirBuilder) Assemble(ctx common.BeamerCtx) (pipe.Pipe, error) {
	d, ok := builder.Get(b, "Directory")
	if !ok {
		return nil, errors.New("mkdir: directory is undefined")
	}

	directory := d.(string)
	if ok, _ := regexp.MatchString(REGEX_VAR_EXPAND, directory); ok {
		d, err := ctx.Expand(directory)
		if err != nil {
			return nil, errors.Errorf("mkdir: expand error: %s", err)
		}
		directory = d.(string)
	}

	fm, ok := builder.Get(b, "FileMode")
	if !ok {
		return nil, errors.New("mkdir: filemode is undefined")
	}

	descr, ok := builder.Get(b, "Description")
	if !ok {
		descr = fmt.Sprintf("mkdir:: %q", directory)
	}

	strict := false
	if st, ok := builder.Get(b, "Strict"); ok {
		strict = st.(bool)
	}

	return func(s *pipe.State) error {
		applog.Infof("execute:: %s", descr)
		err := os.Mkdir(directory, fm.(os.FileMode))
		if !strict && strings.Contains(err.Error(), "file exists") {
			return nil
		}

		return err
	}, nil
}
Пример #9
0
//############################################################################
func (p beamerBuilder) Set(key string, value interface{}) beamerBuilder {
	m, ok := builder.Get(p, "KVStore")

	if ok {
		store := m.(map[string]interface{})
		store[key] = value
		return builder.Set(p, "KVStore", store).(beamerBuilder)
	}

	store := make(map[string]interface{})
	store[key] = value
	return builder.Set(p, "KVStore", store).(beamerBuilder)

}
Пример #10
0
func TestAppend(t *testing.T) {
	b := FooBuilder.Add(1).Add(2)
	v, ok := builder.Get(b, "Add")
	if !ok {
		t.Fatalf("key %v not set", "Add")
	}
	a := v.([]int)
	if len(a) != 2 {
		t.Fatalf("wrong len %d", len(a))
	}
	i := a[0]
	j := a[1]
	if i != 1 || j != 2 {
		t.Errorf("expected [1, 2], got [%d, %d]", i, j)
	}
}
Пример #11
0
func TestUnregisteredBuilder(t *testing.T) {
	b := unregBuilder{}.Add(1)

	x, _ := builder.Get(b, "X")
	expected := []interface{}{1}
	if !reflect.DeepEqual(x.([]interface{}), expected) {
		t.Errorf("expected %v, got %v", expected, x)
	}

	x = builder.GetMap(b)["X"]
	expected = []interface{}{1}
	if !reflect.DeepEqual(x.([]interface{}), expected) {
		t.Errorf("expected %v, got %v", expected, x)
	}

	s := builder.GetStruct(b)
	if s != nil {
		t.Errorf("expected nil, got %v", s)
	}
}