Golang common.LocalID函数代码示例

// RestoreGatewayApp restores the Gateway App
func (m *Mapper) RestoreGatewayApp() error {
	// return err when current state of gateway app is not WaitingRestore
	if err := m.StateTable.CheckGatewayState(state.WaitingRestore); err != nil {
		return state.ErrNotWaitingRestore
	}

	if err := m.StateTable.ChangeGatewayState(state.Restoring,
		common.ToLocalAppID(m.Config.MasterApp.Site, m.Config.MasterApp.AppID)); err != nil {
		return err
	}

	// change back to WaitingRestore only err happened during restoring gateway app
	hanleErr := func(err error) error {
		m.StateTable.ChangeGatewayState(state.WaitingRestore,
			common.ToLocalAppID(m.Config.MasterApp.Site, m.Config.MasterApp.AppID))
		return err
	}

	// disconnect all connecting mqtt clients
	m.Cloud.DisconnectAllMQTTClients()
	// clear DB
	if err := m.Store.ClearDB(); err != nil {
		return hanleErr(err)
	}

	// onboard with gateway app
	if _, err := m.onboardgatewayApp(); err != nil {
		return hanleErr(err)
	}

	// restore gateway
	if err := m.restoreGateway(m.Config.MasterApp.Site, m.Config.MasterApp.AppID); err != nil {
		return hanleErr(err)
	}

	// change state of gateway app to DoneOnboard after restore
	if err := m.StateTable.ChangeGatewayState(state.DoneOnboard,
		common.ToLocalAppID(m.Config.MasterApp.Site, m.Config.MasterApp.AppID)); err != nil {
		return hanleErr(err)
	}

	// Restore all the end-node apps saved on cloud
	apps, err := m.ListAllEndnodeApps()
	if err != nil {
		return err
	}
	for _, a := range apps {
		m.StateTable.ChangeAppState(state.Restoring, common.LocalID(common.LocalAppID(a.ServerLocation, a.AppID)))
		err = m.RestoreEndnodeApp(a)
		if err != nil {
			return err
		}
		m.StateTable.ChangeAppState(state.DoneOnboard, common.LocalID(common.LocalAppID(a.ServerLocation, a.AppID)))
	}

	//change restoreMode to false
	m.StateTable.RestoreMode = false
	return nil
}

func TestOnboardEndnodeAppMapper_gatewayNotReady(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	app := common.App{
		AppID:          "app67890",
		AppKey:         "app0987654321abcdefghijklmn",
		ServerLocation: "jp",
	}
	mapper.StateTable = &state.Table{
		Gateway: state.Onboarding,
		Apps: map[common.LocalID]state.State{
			common.LocalID(app.LocalID()): state.DoneOnboard,
		},
	}
	id, err := mapper.OnboardEndnodeApp(app)
	if err == nil {
		t.Fatal("should fail")
	}
	if id != "" {
		t.Fatal("id should be empty")
	}
	if err.Error() != "state is expected one of DONE_ONBOARD but actual: UNKNONWD_STATE" {
		t.Fatal("fail with unexpected error", err)
	}
}

func TestOnboardEndnodeAppMapper_restoringGateway(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	app := common.App{
		AppID:          "app67890",
		AppKey:         "app0987654321abcdefghijklmn",
		ServerLocation: "jp",
	}
	restoreStates := []state.State{state.WaitingRestore, state.Restoring}
	for _, s := range restoreStates {

		mapper.StateTable = &state.Table{
			Gateway: s,
			Apps: map[common.LocalID]state.State{
				common.LocalID(app.LocalID()): state.WaitingRestore,
			},
			RestoreMode: true,
		}
		id, err := mapper.OnboardEndnodeApp(app)
		if err == nil {
			t.Fatal("should fail")
		}
		if id != "" {
			t.Fatal("id should be empty")
		}
		if err.Error() != "state isn't expected one of WAITING_RESTORE nor RESTORING but actual: UNKNONWD_STATE" {
			t.Fatal("fail with unexpected error", err)
		}
	}
}

func TestPendingEndnodesMapper_restoringGateway(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()

	restoreStates := []state.State{state.WaitingRestore, state.Restoring}
	for _, s := range restoreStates {
		mapper.StateTable = &state.Table{
			Gateway: s,
			Apps: map[common.LocalID]state.State{
				common.LocalID(common.LocalAppID("jp", "app67890")): state.WaitingRestore,
			},
			RestoreMode: true,
		}
		nodes, err := mapper.PendingEndnodes("jp", "app67890")
		if err == nil {
			t.Fatal("should fail")
		}
		if err.Error() != "state isn't expected one of WAITING_RESTORE nor RESTORING but actual: UNKNONWD_STATE" {
			t.Fatal("fail with unexpected error", err)
		}
		if len(nodes) != 0 {
			t.Fatal("nodes should not have items")
		}
	}
}

func TestReplaceEndnodeMapper_basic(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	mapper.StateTable = &state.Table{
		Gateway: state.DoneOnboard,
		Apps: map[common.LocalID]state.State{
			common.LocalID(common.LocalAppID("jp", "app67890")): state.DoneOnboard,
		},
	}
	err := mapper.ReplaceEndnode("jp", "app67890", "T0001endnode", "th.0001endnode")
	if err != nil {
		t.Fatal("TestReplaceEndnodeMapper_basic failed", err)
	}
	if mapper.store.caddr.AppID != "app67890" {
		t.Error("AppID should be \"app67890\":", mapper.store.caddr.AppID)
	}
	if mapper.store.caddr.ServerLocation != "jp" {
		t.Error("ServerLocation should be \"jp\":", mapper.store.caddr.ServerLocation)
	}
	if mapper.store.caddr.ThingID != "th.0001endnode" {
		t.Error("ThingID should be \"th.0001endnode\":", mapper.store.caddr.ThingID)
	}
	if mapper.store.ea.AppID != "app67890" {
		t.Error("AppID should be \"app67890\":", mapper.store.ea.AppID)
	}
	if mapper.store.ea.ServerLocation != "jp" {
		t.Error("ServerLocation should be \"jp\":", mapper.store.ea.ServerLocation)
	}
	if mapper.store.ea.VendorThingID != "T0001endnode" {
		t.Error("VendorThingID should be \"T0001endnode\":", mapper.store.ea.VendorThingID)
	}

}

func TestRestoreGatewayApp_ENAppFail(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	allEndnodes := []common.App{
		{ServerLocation: "jp", AppID: "id1", AppKey: "key1"},
	}
	mapper.StateTable = &state.Table{
		Gateway: state.WaitingRestore,
		Apps:    map[common.LocalID]state.State{},
	}

	mapper.cloud.err4OnboardEndnodeApp = errors.New("onboard endnode app fail")
	mapper.cloud.apps4ListAllEndnodeApps = allEndnodes
	err := mapper.RestoreGatewayApp()
	if err == nil {
		t.Error("should fail", err)
	} else {
		if err.Error() != "onboard endnode app fail" {
			t.Error("fail with other error", err)
		}
	}
	if mapper.StateTable.Gateway != state.DoneOnboard {
		t.Error("state of gateway app should be DoneOnboard", mapper.StateTable.Gateway)
	}
	enState := mapper.StateTable.Apps[common.LocalID(common.LocalAppID("jp", "id1"))]
	if enState != state.Restoring {
		t.Error("state of endnode app is not Restoring", enState)
	}
}

func TestOnboardEndnodeAppMapper_wrongPassword(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	app := common.App{
		AppID:          "app67890",
		AppKey:         "app0987654321abcdefghijklmn",
		ServerLocation: "jp",
	}
	mapper.StateTable = &state.Table{
		Gateway: state.DoneOnboard,
		Apps: map[common.LocalID]state.State{
			common.LocalID(app.LocalID()): state.DoneOnboard,
		},
	}
	mapper.cloud.err4OnboardEndnodeApp = common.ErrWrongPassword
	id, err := mapper.OnboardEndnodeApp(app)
	if err == nil {
		t.Fatal("should fail")
	}
	if id != "" {
		t.Fatal("id should be empty")
	}
	if err.Error() != "wrong password of gateway" {
		t.Fatal("fail with unexpected error", err)
	}
}

// test OnboardEndnodeApp
func TestOnboardEndnodeAppMapper_basic(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	app := common.App{
		AppID:          "app67890",
		AppKey:         "app0987654321abcdefghijklmn",
		ServerLocation: "jp",
	}
	mapper.StateTable = &state.Table{
		Gateway: state.DoneOnboard,
		Apps: map[common.LocalID]state.State{
			common.LocalID(app.LocalID()): state.WaitingOnboard,
		},
	}
	id, err := mapper.OnboardEndnodeApp(app)
	if err != nil {
		t.Fatal("TestOnboardEndnodeAppMapper_basic failed", err)
	}
	if id != "th.0001endnode" {
		t.Error("ThingID should be \"th.0001endnode\":", id)
	}
	if mapper.store.appID != "app67890" {
		t.Error("AppID should be \"app67890\":", mapper.store.appID)
	}
	if mapper.cloud.app.AppID != "app67890" {
		t.Error("AppID should be \"app67890\":", mapper.cloud.app.AppID)
	}
	if mapper.cloud.app.AppKey != "app0987654321abcdefghijklmn" {
		t.Error("AppKey should be \"app0987654321abcdefghijklmn\":", mapper.cloud.app.AppKey)
	}
	if mapper.cloud.app.ServerLocation != "jp" {
		t.Error("ServerLocation should be \"jp\":", mapper.cloud.app.ServerLocation)
	}
	if mapper.cloud.called4SaveEndnodeApp != true {
		t.Error("endnode app should be saved on gateway app")
	}

	if mapper.StateTable.Apps[common.LocalID(app.LocalID())] != state.DoneOnboard {
		t.Fatal("endnode app should be DoneOnboard", mapper.StateTable.Apps[common.LocalID(app.LocalID())])
	}
}

// LoadTable load state table from store
func LoadTable(s store.Store, gwID common.LocalID, restoreMode bool) (*Table, error) {
	allStates := map[common.LocalID]State{}

	onboardedApps, err := s.GetAllOnboardedApp()
	if err != nil {
		return nil, err
	}

	// defaultState is for the gateway already onboarded
	var defaultState State
	if restoreMode {
		defaultState = WaitingRestore
	} else {
		defaultState = DoneOnboard
	}

	var gwState State
	for _, gateway := range onboardedApps {
		if gwID == common.LocalID(gateway.LocalID()) {
			gwState = defaultState
		}
		allStates[common.LocalID(gateway.LocalID())] = defaultState
	}

	// if gateway is not onboarded, the value under normal mode is WaitingOnboard
	if gwState == 0 {
		if restoreMode {
			gwState = WaitingRestore
		} else {
			gwState = WaitingOnboard
		}
	}
	st := &Table{
		Gateway:     gwState,
		Apps:        allStates,
		RestoreMode: restoreMode,
	}
	return st, nil
}

// OnboardEndnodeApp onboards the Gateway for the Endnode App
func (m *Mapper) OnboardEndnodeApp(app common.App) (string, error) {

	if app.ServerLocation == m.Config.MasterApp.Site && app.AppID == m.Config.MasterApp.AppID {
		return m.OnboardGatewayApp()
	}
	// verify state first
	if m.StateTable.RestoreMode {
		return "", state.ErrRestoringGateway
	}
	// if gateway state is not DoneOnboard, then resturn err
	if err := m.StateTable.CheckGatewayState(state.DoneOnboard); err != nil {
		return "", state.ErrGatewayAppGatewayNotReady
	}
	if err := m.StateTable.CheckAppState(common.LocalID(app.LocalID()), state.Onboarding); err == nil {
		return "", state.ErrOnboarding
	}

	// change state of endnode app to onboarding before onboard
	if err := m.StateTable.ChangeAppState(state.Onboarding, common.LocalID(app.LocalID())); err != nil {
		return "", err
	}

	handleErr := func(err error) (string, error) {
		m.StateTable.ChangeAppState(state.WaitingOnboard, common.LocalID(app.LocalID()))
		return "", err
	}
	gwID, err := m.onboardGateway(app, true)
	if err != nil {
		return handleErr(err)
	}

	// change state of endnode app to DoneOnboard after onboard
	if err := m.StateTable.ChangeAppState(state.DoneOnboard, common.LocalID(app.LocalID())); err != nil {
		return handleErr(err)
	}

	return gwID, nil
}

func TestCompleteEndnodeOnboardingMapper_ENAppNotDoneOnboard(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()

	mapper.StateTable = &state.Table{
		Gateway: state.DoneOnboard,
		Apps: map[common.LocalID]state.State{
			common.LocalID(common.LocalAppID("jp", "app67890")): state.Onboarding,
		},
	}
	err := mapper.CompleteEndnodeOnboarding("jp", "app67890", "T0001endnode", "th.0001endnode")
	if err == nil {
		t.Fatal("TestCompleteEndnodeOnboardingMapper_restoringGateway should fail")
	}
	if err.Error() != "state is expected one of DONE_ONBOARD but actual: UNKNONWD_STATE" {
		t.Fatal("fail with other error", err)
	}
}

// test GetGatewayID
func TestGetGatewayIDMapper_basic(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	mapper.StateTable = &state.Table{
		Gateway: state.DoneOnboard,
		Apps: map[common.LocalID]state.State{
			common.LocalID(common.LocalAppID("jp", "app67890")): state.DoneOnboard,
		},
	}
	id, err := mapper.GetGatewayID("jp", "app67890")
	if err != nil {
		t.Fatal("TestGetGatewayIDMapper_basic failed", err)
	}
	if id != "th.0002gateway" {
		t.Error("ThingID should be \"th.0002gateway\":", id)
	}
	if mapper.store.appID4FindGatewayByAppID != "app67890" {
		t.Error("AppID should be \"app67890\":", mapper.store.appID)
	}
}

func TestGetGatewayIDMapper_ENAppNotDoneOnboard(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	mapper.StateTable = &state.Table{
		Gateway: state.DoneOnboard,
		Apps: map[common.LocalID]state.State{
			common.LocalID(common.LocalAppID("jp", "app67890")): state.Onboarding,
		},
	}
	id, err := mapper.GetGatewayID("jp", "app67890")
	if err == nil {
		t.Fatal("should fail")
	}

	if id != "" {
		t.Fatal("id should be empty")
	}
	if err.Error() != "state is expected one of DONE_ONBOARD but actual: UNKNONWD_STATE" {
		t.Fatal("faild with other error", err)
	}
}

func TestPendingEndnodesMapper_gatewayNotReady(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()

	mapper.StateTable = &state.Table{
		Gateway: state.Onboarding,
		Apps: map[common.LocalID]state.State{
			common.LocalID(common.LocalAppID("jp", "app67890")): state.DoneOnboard,
		},
	}
	nodes, err := mapper.PendingEndnodes("jp", "app67890")
	if err == nil {
		t.Fatal("should fail")
	}
	if err.Error() != "state is expected one of DONE_ONBOARD but actual: UNKNONWD_STATE" {
		t.Fatal("fail with unexpected error", err)
	}
	if len(nodes) != 0 {
		t.Fatal("nodes should not have items")
	}

}

func TestCompleteEndnodeOnboardingMapper_restoringGateway(t *testing.T) {
	mapper := newMapper()
	defer mapper.clear()
	restoreStates := []state.State{state.WaitingRestore, state.Restoring}
	for _, s := range restoreStates {

		mapper.StateTable = &state.Table{
			Gateway: s,
			Apps: map[common.LocalID]state.State{
				common.LocalID(common.LocalAppID("jp", "app67890")): state.WaitingRestore,
			},
			RestoreMode: true,
		}
		err := mapper.CompleteEndnodeOnboarding("jp", "app67890", "T0001endnode", "th.0001endnode")
		if err == nil {
			t.Fatal("TestCompleteEndnodeOnboardingMapper_restoringGateway should fail")
		}
		if err.Error() != "state isn't expected one of WAITING_RESTORE nor RESTORING but actual: UNKNONWD_STATE" {
			t.Fatal("fail with other error", err)
		}
	}
}