func TestAuthToken(t *testing.T) {
ts := cltest.NewClientTestServer()
defer ts.Close()
ms := NewMemStore()
mender := newTestMender(nil,
menderConfig{
ServerURL: ts.URL,
},
testMenderPieces{
MenderPieces: MenderPieces{
store: ms,
},
},
)
ms.WriteAll(authTokenName, []byte("tokendata"))
token, err := ms.ReadAll(authTokenName)
assert.NoError(t, err)
assert.Equal(t, []byte("tokendata"), token)
ts.Update.Unauthorized = true
_, updErr := mender.CheckUpdate()
assert.EqualError(t, updErr.Cause(), client.ErrNotAuthorized.Error())
token, err = ms.ReadAll(authTokenName)
assert.Equal(t, os.ErrNotExist, err)
assert.Empty(t, token)
}
func Test_CheckUpdateSimple(t *testing.T) {
// create temp dir
td, _ := ioutil.TempDir("", "mender-install-update-")
defer os.RemoveAll(td)
// prepare fake manifest file, with bogus
manifest := path.Join(td, "manifest")
var mender *mender
mender = newTestMender(nil, menderConfig{
ServerURL: "bogusurl",
}, testMenderPieces{})
up, err := mender.CheckUpdate()
assert.Error(t, err)
assert.Nil(t, up)
srv := cltest.NewClientTestServer()
defer srv.Close()
srv.Update.Has = true
mender = newTestMender(nil,
menderConfig{
ServerURL: srv.URL,
},
testMenderPieces{})
mender.manifestFile = manifest
ioutil.WriteFile(manifest, []byte("IMAGE_ID=fake-id"), 0600)
currID := mender.GetCurrentImageID()
assert.Equal(t, "fake-id", currID)
// make image ID same as current, will result in no updates being available
srv.Update.Data.Image.YoctoID = currID
up, err = mender.CheckUpdate()
assert.Equal(t, err, NewTransientError(os.ErrExist))
assert.NotNil(t, up)
// make image ID different from current
srv.Update.Data.Image.YoctoID = currID + "-fake"
srv.Update.Has = true
up, err = mender.CheckUpdate()
assert.NoError(t, err)
assert.NotNil(t, up)
assert.Equal(t, *up, srv.Update.Data)
// pretend that we got 204 No Content from the server, i.e empty response body
srv.Update.Has = false
up, err = mender.CheckUpdate()
assert.NoError(t, err)
assert.Nil(t, up)
}
func TestMenderReportStatus(t *testing.T) {
srv := cltest.NewClientTestServer()
defer srv.Close()
ms := NewMemStore()
mender := newTestMender(nil,
menderConfig{
ServerURL: srv.URL,
},
testMenderPieces{
MenderPieces: MenderPieces{
store: ms,
},
},
)
ms.WriteAll(authTokenName, []byte("tokendata"))
err := mender.Authorize()
assert.NoError(t, err)
srv.Auth.Verify = true
srv.Auth.Token = []byte("tokendata")
// 1. successful report
err = mender.ReportUpdateStatus(
client.UpdateResponse{
ID: "foobar",
},
client.StatusSuccess,
)
assert.Nil(t, err)
assert.Equal(t, client.StatusSuccess, srv.Status.Status)
// 2. pretend authorization fails, server expects a different token
srv.Reset()
srv.Auth.Token = []byte("footoken")
srv.Auth.Verify = true
err = mender.ReportUpdateStatus(
client.UpdateResponse{
ID: "foobar",
},
client.StatusSuccess,
)
assert.NotNil(t, err)
}
func TestMenderInventoryRefresh(t *testing.T) {
// create temp dir
td, _ := ioutil.TempDir("", "mender-install-update-")
defer os.RemoveAll(td)
// prepare fake manifest file, it is read when submitting inventory to
// fill some default fields (device_type, image_id)
manifest := path.Join(td, "manifest")
ioutil.WriteFile(manifest, []byte("IMAGE_ID=fake-id\nDEVICE_TYPE=foo-bar"), 0600)
srv := cltest.NewClientTestServer()
defer srv.Close()
ms := NewMemStore()
mender := newTestMender(nil,
menderConfig{
ServerURL: srv.URL,
},
testMenderPieces{
MenderPieces: MenderPieces{
store: ms,
},
},
)
mender.manifestFile = manifest
ms.WriteAll(authTokenName, []byte("tokendata"))
merr := mender.Authorize()
assert.NoError(t, merr)
// prepare fake inventory scripts
// 1. setup a temporary path $TMPDIR/mendertest<random>/inventory
tdir, err := ioutil.TempDir("", "mendertest")
assert.NoError(t, err)
invpath := path.Join(tdir, "inventory")
err = os.MkdirAll(invpath, os.FileMode(syscall.S_IRWXU))
assert.NoError(t, err)
defer os.RemoveAll(tdir)
oldDefaultPathDataDir := defaultPathDataDir
// override datadir path for subsequent getDataDirPath() calls
defaultPathDataDir = tdir
// 1a. no scripts hence no inventory data, submit should have been
// called with default inventory attributes only
srv.Auth.Verify = true
srv.Auth.Token = []byte("tokendata")
err = mender.InventoryRefresh()
assert.Nil(t, err)
assert.True(t, srv.Inventory.Called)
exp := []client.InventoryAttribute{
{"device_type", "foo-bar"},
{"image_id", "fake-id"},
{"client_version", "unknown"},
}
for _, a := range exp {
assert.Contains(t, srv.Inventory.Attrs, a)
}
// 2. fake inventory script
err = ioutil.WriteFile(path.Join(invpath, "mender-inventory-foo"),
[]byte(`#!/bin/sh
echo foo=bar`),
os.FileMode(syscall.S_IRWXU))
assert.NoError(t, err)
srv.Reset()
srv.Auth.Verify = true
srv.Auth.Token = []byte("tokendata")
err = mender.InventoryRefresh()
assert.Nil(t, err)
exp = []client.InventoryAttribute{
{"device_type", "foo-bar"},
{"image_id", "fake-id"},
{"client_version", "unknown"},
{"foo", "bar"},
}
for _, a := range exp {
assert.Contains(t, srv.Inventory.Attrs, a)
}
// 3. pretend client is no longer authorized
srv.Auth.Token = []byte("footoken")
err = mender.InventoryRefresh()
assert.NotNil(t, err)
// restore old datadir path
defaultPathDataDir = oldDefaultPathDataDir
}
func TestMenderLogUpload(t *testing.T) {
srv := cltest.NewClientTestServer()
defer srv.Close()
ms := NewMemStore()
mender := newTestMender(nil,
menderConfig{
ServerURL: srv.URL,
},
testMenderPieces{
MenderPieces: MenderPieces{
store: ms,
},
},
)
ms.WriteAll(authTokenName, []byte("tokendata"))
err := mender.Authorize()
assert.NoError(t, err)
srv.Auth.Verify = true
srv.Auth.Token = []byte("tokendata")
// 1. log upload successful
logs := []byte(`{ "messages":
[{ "time": "12:12:12", "level": "error", "msg": "log foo" },
{ "time": "12:12:13", "level": "debug", "msg": "log bar" }]
}`)
err = mender.UploadLog(
client.UpdateResponse{
ID: "foobar",
},
logs,
)
assert.Nil(t, err)
assert.JSONEq(t, `{
"messages": [
{
"time": "12:12:12",
"level": "error",
"msg": "log foo"
},
{
"time": "12:12:13",
"level": "debug",
"msg": "log bar"
}
]}`, string(srv.Log.Logs))
// 2. pretend authorization fails, server expects a different token
srv.Auth.Token = []byte("footoken")
err = mender.UploadLog(
client.UpdateResponse{
ID: "foobar",
},
logs,
)
assert.NotNil(t, err)
}
func TestMenderAuthorize(t *testing.T) {
runner := newTestOSCalls("", -1)
rspdata := []byte("foobar")
atok := client.AuthToken("authorized")
authMgr := &testAuthManager{
authorized: true,
authtoken: atok,
}
srv := cltest.NewClientTestServer()
defer srv.Close()
mender := newTestMender(&runner,
menderConfig{
ServerURL: srv.URL,
},
testMenderPieces{
MenderPieces: MenderPieces{
authMgr: authMgr,
},
})
// we should start with no token
assert.Equal(t, noAuthToken, mender.authToken)
// 1. client already authorized
err := mender.Authorize()
assert.NoError(t, err)
// no need to build send request if auth data is valid
assert.False(t, srv.Auth.Called)
assert.Equal(t, atok, mender.authToken)
// 2. pretend caching of authorization code fails
authMgr.authtokenErr = errors.New("auth code load failed")
mender.authToken = noAuthToken
err = mender.Authorize()
assert.Error(t, err)
// no need to build send request if auth data is valid
assert.False(t, srv.Auth.Called)
assert.Equal(t, noAuthToken, mender.authToken)
authMgr.authtokenErr = nil
// 3. call the server, server denies authorization
authMgr.authorized = false
err = mender.Authorize()
assert.Error(t, err)
assert.False(t, err.IsFatal())
assert.True(t, srv.Auth.Called)
assert.Equal(t, noAuthToken, mender.authToken)
// 4. pretend authorization manager fails to parse response
srv.Auth.Called = false
authMgr.testAuthDataMessenger.rspError = errors.New("response parse error")
// we need the server authorize the client
srv.Auth.Authorize = true
srv.Auth.Token = rspdata
err = mender.Authorize()
assert.Error(t, err)
assert.False(t, err.IsFatal())
assert.True(t, srv.Auth.Called)
// response data should be passed verbatim to AuthDataMessenger interface
assert.Equal(t, rspdata, authMgr.testAuthDataMessenger.rspData)
// 5. authorization manger throws no errors, server authorizes the client
srv.Auth.Called = false
authMgr.testAuthDataMessenger.rspError = nil
// server will authorize the client
srv.Auth.Authorize = true
srv.Auth.Token = rspdata
err = mender.Authorize()
// all good
assert.NoError(t, err)
// Authorize() should have reloaded the cache (token comes from mock
// auth manager)
assert.Equal(t, atok, mender.authToken)
}
