Esempio n. 1
0
func TestParseThumbName(t *testing.T) {
	path := "foo-20x40.png"
	name, geometry, err := ParseThumbName(path)

	assert.Nil(t, err)
	assert.Equal(t, "foo", name)
	assert.Equal(t, 20, geometry.Width)
	assert.Equal(t, 40, geometry.Height)

	path = "foo-xyz-20x40.png"
	name, geometry, err = ParseThumbName(path)

	assert.Nil(t, err)
	assert.Equal(t, "foo-xyz", name)
	assert.Equal(t, 20, geometry.Width)
	assert.Equal(t, 40, geometry.Height)

	path = "foo20x40.png" //bad filename
	name, geometry, err = ParseThumbName(path)

	assert.NotNil(t, err)
	assert.Equal(t, "", name)
	assert.Equal(t, 0, geometry.Width)
	assert.Equal(t, 0, geometry.Height)
}
Esempio n. 2
0
func TestTranslate(t *testing.T) {
	defer resetLocales()

	en := NewLocale("en")
	en.Add("greeting", "hello")
	en.Add("greeting2", "hello2")
	AddLocale(en)

	it := NewLocale("it")
	it.Add("greeting", "ciao")
	AddLocale(it)

	var value string
	var err error

	err = SetLocale("en")
	assert.Nil(t, err)
	assert.Equal(t, en, currentLocale)

	value, err = Translate("greeting")
	assert.Nil(t, err)
	assert.Equal(t, "hello", value)

	value, err = Translate("greeting2")
	assert.Nil(t, err)
	assert.Equal(t, "hello2", value)

	err = SetLocale("it")
	assert.Nil(t, err)
	assert.Equal(t, it, currentLocale)

	value, err = Translate("greeting")
	assert.Nil(t, err)
	assert.Equal(t, "ciao", value)

	value, err = Translate("greeting2")
	assert.NotNil(t, err)
	assert.Type(t, "*i18n.TranslationMissing", err)

	err = SetLocale("es")
	assert.NotNil(t, err)
	assert.Type(t, "*i18n.LocaleMissing", err)
	assert.True(t, currentLocale == nil)

	value, err = Translate("greeting")
	assert.NotNil(t, err)
	assert.Equal(t, "Current locale is not set", err.Error())
}
Esempio n. 3
0
func TestLocale_T(t *testing.T) {
	locale := NewLocale("en")
	locale.Add("greeting", "hello %s")
	value, err := locale.T("greeting", "world")
	assert.Nil(t, err)
	assert.Equal(t, "hello world", value)
}
Esempio n. 4
0
func TestPlate_Execute(t *testing.T) {
	defer os.RemoveAll("__test-data__")
	p := newPlate("__test-fixtures__", "__test-data__")
	p.execute("go", []string{"program-name", "outpath", "World"}...)

	paths := map[string]string{
		"__test-data__/main.go": `package main

import "fmt"

func main() {
	fmt.Println("Hello World")
}`,
		"__test-data__/main_test.go": `package main

import "testing"

func TestFoo(t *testing.T) {
}`,
		"__test-data__/config/app.config": `config file`,
	}

	for path, expectedContent := range paths {
		f, err := os.Open(path)
		assert.Nil(t, err)

		content, err := ioutil.ReadAll(f)
		if err != nil {
			logPkg.Fatal(err)
		}
		assert.Equal(t, expectedContent, string(content))
	}
}
Esempio n. 5
0
func TestNewFinder(t *testing.T) {
	f, err := newFinder("http://example.com")
	expectedURL, _ := url.Parse("http://example.com")

	assert.Nil(t, err)
	assert.Equal(t, expectedURL, f.URL)
}
Esempio n. 6
0
func TestBundler_Bundle(t *testing.T) {
	defer testRemoveTestDataFolder()
	b := testNewBundler()
	b.bundle()

	tests := map[string]string{
		"application": `
function file1(){return"file1"}
function file2(){return"file2"}`,
		"admin": `
function admin1(){return"admin1"}
function admin2(){return"admin2"}
function editor(){return"editor"}`,
	}

	for filename, expectedContent := range tests {
		h := md5.New()
		io.Copy(h, bytes.NewBufferString(expectedContent))

		path := fmt.Sprintf("%s/%s-%x.js", b.outputPath, filename, h.Sum(nil))
		f, err := os.Open(path)

		content, err := ioutil.ReadAll(f)
		assert.Nil(t, err)

		assert.Equal(t, expectedContent, string(content))
	}
}
Esempio n. 7
0
func TestParseConfig(t *testing.T) {
	content := `javascripts:
  application:
    - file-1.js
    - file-2.js
  admin:
    - file-3.js
    - file-4.js
`
	r := bytes.NewBufferString(content)

	c, err := parseConfig(r)
	assert.Nil(t, err)
	assert.Equal(t, 2, len(c.Javascripts))

	assert.Type(t, "[]string", c.Javascripts["application"])
	assert.Equal(t, 2, len(c.Javascripts["application"]))
	assert.Equal(t, "file-1.js", c.Javascripts["application"][0])
	assert.Equal(t, "file-2.js", c.Javascripts["application"][1])

	assert.Type(t, "[]string", c.Javascripts["admin"])
	assert.Equal(t, 2, len(c.Javascripts["admin"]))
	assert.Equal(t, "file-3.js", c.Javascripts["admin"][0])
	assert.Equal(t, "file-4.js", c.Javascripts["admin"][1])
}
Esempio n. 8
0
func TestSetPort(t *testing.T) {
	resetGlobalEnv()

	assert.Nil(t, GetVar("port"))

	SetPort(80)
	assert.Equal(t, 80, GetVar("port"))

	resetGlobalEnv()
}
Esempio n. 9
0
func TestSetHost(t *testing.T) {
	resetGlobalEnv()

	assert.Nil(t, GetVar("host"))

	SetHost("1.2.3.4")
	assert.Equal(t, "1.2.3.4", GetVar("host"))

	resetGlobalEnv()
}
Esempio n. 10
0
func TestGetVar(t *testing.T) {
	resetGlobalEnv()
	env["foo-2"] = "bar-2"
	assert.Equal(t, "bar-2", GetVar("foo-2"))

	assert.Nil(t, GetVar("os_foo"))
	os.Setenv("TRAFFIC_OS_FOO", "bar")
	assert.Equal(t, "bar", GetVar("os_foo"))

	resetGlobalEnv()
}
Esempio n. 11
0
func TestThumbFromPath(t *testing.T) {
	path := "/path/to/image/foo-20x40.png"
	thumb, err := ThumbFromPath(path)

	assert.Nil(t, err)
	assert.Equal(t, path, thumb.Path)
	assert.Equal(t, "/path/to/image", thumb.Dir)
	assert.Equal(t, "foo", thumb.Name)
	assert.Equal(t, ".png", thumb.Ext)
	assert.Equal(t, "/path/to/image/foo.png", thumb.MainPath)
}
Esempio n. 12
0
func TestClient_newRequest(t *testing.T) {
	c := New(&Environment{
		SearchApiKey:  "foo",
		DisplayApiKey: "bar",
	})
	v := url.Values{}
	v.Set("p1", "v1")
	r, err := c.newRequest("/foo", v)
	assert.Nil(t, err)
	expectedURI := "http://test.lyricfind.com/api_service/foo?output=json&p1=v1"
	assert.Equal(t, expectedURI, r.URL.String())
}
Esempio n. 13
0
func TestPlate_OpenTemplate(t *testing.T) {
	p := newPlate("__test-fixtures__", "tmp")
	mainTpl, err := p.openTemplate("go")
	assert.NotNil(t, mainTpl)
	assert.Nil(t, err)
	assert.Equal(t, 6, len(mainTpl.Templates()))

	names := []string{"main.go", "main_test.go", "config/app.config", "bin/test_command.sh"}
	for _, name := range names {
		tpl := mainTpl.Lookup(name)
		assert.NotNil(t, tpl)
	}
}
Esempio n. 14
0
func TestClient_Search(t *testing.T) {
	c := New(&Environment{
		SearchApiKey:  "foo",
		DisplayApiKey: "bar",
		Live:          true,
	})
	fc := newFakeHttpClient("search")
	c.httpClient = fc
	sr, err := c.Search(IPAddress("1.2.3.4"), &SearchOptions{Artist: "artist-foo"})
	assert.Nil(t, err)
	assert.Equal(t, 2, len(sr.Tracks))
	assert.Equal(t, "/search.do", fc.request.URL.Path)
}
Esempio n. 15
0
func TestClient_Lyric(t *testing.T) {
	c := New(&Environment{
		SearchApiKey:  "foo",
		DisplayApiKey: "bar",
		Live:          true,
	})
	fc := newFakeHttpClient("lyric")
	c.httpClient = fc
	sr, err := c.Lyric(IPAddress("1.2.3.4"), "test client", 1234)
	assert.Nil(t, err)
	assert.Equal(t, "Lorem Ipsum", sr.Track.Title)
	assert.Equal(t, "/lyric.do", fc.request.URL.Path)
}
Esempio n. 16
0
func TestLoad(t *testing.T) {
	defer resetLocales()

	files := map[string]string{
		"en.conf": `
		[en]
    greeting = "hello"
    `,
		"it.conf": `
		[it]
    greeting = "ciao"
    `,
		"other_en.conf": `
    [en] # add more translations for locale "en"
    greeting2 = "hello2"
    `,
		"other_it.conf": `
    [it] # add more translations for locale "it"
    greeting2 = "ciao2"
    `,
		"es.conf": `# blank file`,
	}

	withTestData(files, func(folderPath string) {
		err := Load(filepath.Join(folderPath, "*.conf"))
		assert.Nil(t, err)
		assert.Equal(t, 2, len(locales))

		tests := [][]string{
			[]string{"en", "greeting", "hello"},
			[]string{"en", "greeting2", "hello2"},
			[]string{"it", "greeting", "ciao"},
			[]string{"it", "greeting2", "ciao2"},
		}

		for _, items := range tests {
			code := items[0]
			key := items[1]
			value := items[2]
			locale := GetLocale(code)

			assert.NotNil(t, locale)
			assert.Type(t, "*i18n.Locale", locale)
			assert.Equal(t, code, locale.Code)

			tr := locale.Translations[key]
			assert.Equal(t, value, tr.Value())
		}
	})
}
Esempio n. 17
0
func TestParseGeometry(t *testing.T) {
	geometry, err := ParseGeometry("200x300")
	assert.Nil(t, err)
	assert.Equal(t, 200, geometry.Width)
	assert.Equal(t, 300, geometry.Height)

	geometry, err = ParseGeometry("200x")
	assert.Nil(t, err)
	assert.Equal(t, 200, geometry.Width)
	assert.Equal(t, 0, geometry.Height)

	geometry, err = ParseGeometry("x300")
	assert.Nil(t, err)
	assert.Equal(t, 0, geometry.Width)
	assert.Equal(t, 300, geometry.Height)

	geometry, err = ParseGeometry("x")
	assert.NotNil(t, err)
	assert.Type(t, "main.ErrorBadGeometry", err)

	geometry, err = ParseGeometry("bad-geometry")
	assert.NotNil(t, err)
	assert.Type(t, "main.ErrorBadGeometry", err)
}
Esempio n. 18
0
func TestSetLocale(t *testing.T) {
	defer resetLocales()

	locale := NewLocale("en")
	AddLocale(locale)

	var err error

	err = SetLocale("en")
	assert.Nil(t, err)
	assert.Equal(t, locale, currentLocale)

	err = SetLocale("foo")
	assert.NotNil(t, err)
}
Esempio n. 19
0
func TestBundler_InitOutputPath(t *testing.T) {
	defer testRemoveTestDataFolder()

	b := testNewBundler()

	_, err := os.Stat(testDataFolder)
	if err == nil {
		t.Errorf("%s followed should must be removed before runnning tests", testDataFolder)
	}

	b.initOutputPath()

	fi, err := os.Stat(b.outputPath)
	assert.Nil(t, err)
	assert.True(t, fi.IsDir())
}
Esempio n. 20
0
func TestLoadFile(t *testing.T) {
	defer resetLocales()

	files := map[string]string{
		"en.conf": `
    greeting: hello

    [en_GB]
    greeting: hello GB

    [en_US]
    greeting: hello US

    [en_GB]
    greeting2: hello 2 GB
    `,
	}

	withTestData(files, func(folderPath string) {
		err := loadFile(filepath.Join(folderPath, "en.conf"))
		assert.Nil(t, err)
		assert.Equal(t, 3, len(locales))

		tests := [][]string{
			[]string{"en", "greeting", "hello"},
			[]string{"en_GB", "greeting", "hello GB"},
			[]string{"en_GB", "greeting2", "hello 2 GB"},
			[]string{"en_US", "greeting", "hello US"},
		}

		for _, items := range tests {
			code := items[0]
			key := items[1]
			value := items[2]
			locale := GetLocale(code)

			assert.NotNil(t, locale)
			assert.Type(t, "*i18n.Locale", locale)
			assert.Equal(t, code, locale.Code)

			tr := locale.Translations[key]
			assert.Equal(t, value, tr.Value())
		}
	})
}
Esempio n. 21
0
func TestClient_newLyricRequest(t *testing.T) {
	c := New(&Environment{
		SearchApiKey:  "foo",
		DisplayApiKey: "bar",
	})
	r, err := c.newLyricRequest(IPAddress("1.2.3.4"), "Test Client", 1234)
	assert.Nil(t, err)

	v := r.URL.Query()
	expected := url.Values{
		"output":    []string{"json"},
		"apikey":    []string{"bar"},
		"reqtype":   []string{"default"},
		"trackid":   []string{"amg:1234"},
		"ipaddress": []string{"1.2.3.4"},
		"useragent": []string{"Test Client"},
	}
	assert.Equal(t, expected, v)
}
Esempio n. 22
0
func TestClient_newSearchRequest(t *testing.T) {
	c := New(&Environment{
		SearchApiKey:  "foo",
		DisplayApiKey: "bar",
	})
	r, err := c.newSearchRequest(IPAddress("1.2.3.4"), &SearchOptions{Artist: "artist-foo"})
	assert.Nil(t, err)

	v := r.URL.Query()
	expected := url.Values{
		"output":     []string{"json"},
		"apikey":     []string{"foo"},
		"reqtype":    []string{"default"},
		"searchtype": []string{"track"},
		"artist":     []string{"artist-foo"},
		"ipaddress":  []string{"1.2.3.4"},
		"displaykey": []string{"bar"},
	}
	assert.Equal(t, expected, v)
}
Esempio n. 23
0
func TestMinifier_min(t *testing.T) {
	original := `// is.js

// (c) 2001 Douglas Crockford
// 2001 June 3


// is

// The -is- object is used to identify the browser.  Every browser edition
// identifies itself, but there is no standard way of doing it, and some of
// the identification is deceptive. This is because the authors of web
// browsers are liars. For example, Microsoft's IE browsers claim to be
// Mozilla 4. Netscape 6 claims to be version 5.

// Warning: Do not use this awful, awful code or any other thing like it.
// Seriously.

var is = {
    ie:      navigator.appName == 'Microsoft Internet Explorer',
    java:    navigator.javaEnabled(),
    ns:      navigator.appName == 'Netscape',
    ua:      navigator.userAgent.toLowerCase(),
    version: parseFloat(navigator.appVersion.substr(21)) ||
             parseFloat(navigator.appVersion),
    win:     navigator.platform == 'Win32'
}

is.mac = is.ua.indexOf('mac') >= 0;

if (is.ua.indexOf('opera') >= 0) {
    is.ie = is.ns = false;
    is.opera = true;
}

if (is.ua.indexOf('gecko') >= 0) {
    is.ie = is.ns = false;
    is.gecko = true;
}`

	expected := `
var is={ie:navigator.appName=='Microsoft Internet Explorer',java:navigator.javaEnabled(),ns:navigator.appName=='Netscape',ua:navigator.userAgent.toLowerCase(),version:parseFloat(navigator.appVersion.substr(21))||parseFloat(navigator.appVersion),win:navigator.platform=='Win32'}
is.mac=is.ua.indexOf('mac')>=0;if(is.ua.indexOf('opera')>=0){is.ie=is.ns=false;is.opera=true;}
if(is.ua.indexOf('gecko')>=0){is.ie=is.ns=false;is.gecko=true;}`

	output := bytes.NewBufferString("")
	m := newMinifier(bytes.NewBufferString(original), output)
	err := m.min()
	assert.Nil(t, err)
	assert.Equal(t, expected, string(output.Bytes()))

	m = newMinifier(bytes.NewBufferString(`var x = 0; /*`), output)
	err = m.min()
	assert.NotNil(t, err)
	assert.Equal(t, errorUnterminatedComment, err)

	m = newMinifier(bytes.NewBufferString(`var x = "unterminated`), output)
	err = m.min()
	assert.NotNil(t, err)
	assert.Equal(t, errorUnterminatedStringLiteral, err)

	m = newMinifier(bytes.NewBufferString(`var x = /[1-2/`), output)
	err = m.min()
	assert.NotNil(t, err)
	assert.Equal(t, errorUnterminatedSetInRegexpLiteral, err)

	m = newMinifier(bytes.NewBufferString(`var x = /hello`), output)
	err = m.min()
	assert.NotNil(t, err)
	assert.Equal(t, errorUnterminatedRegexpLiteral, err)
}