Step 7. Testing of operations

import { ConfigParams } from 'pip-services4-components-node';
import { Descriptor } from 'pip-services4-components-node';
import { ManagedReferences } from 'pip-services4-container-node';

import { IAccountsClientV1 } from '../../src/clients/version1/IAccountsClientV1';
import { AccountV1 } from '../../src/clients/version1/AccountV1';
import { IRolesClientV1 } from '../../src/clients/version1/IRolesClientV1';
import { ISessionsClientV1 } from '../../src/clients/version1/ISessionsClientV1';
import { ISitesClientV1 } from '../../src/clients/version1/ISitesClientV1';
import { SiteV1 } from '../../src/clients/version1/SiteV1';

import { TestUsers } from './TestUsers';
import { TestSites } from './TestSites';
import { ClientFacadeFactory } from '../../src/build/ClientFacadeFactory';
import { HttpEndpoint, DefaultRpcFactory } from 'pip-services3-rpc-nodex';
import { FacadeServiceV1 } from '../../src/services/version1/FacadeServiceV1';
import { FacadeServiceV2 } from '../../src/services/version2/FacadeServiceV2';
import { AccountsMemoryClientV1 } from '../../src/clients/version1/AccountsMemoryClientV1';
import { SessionsMemoryClientV1 } from '../../src/clients/version1/SessionsMemoryClientV1';
import { PasswordsNullClientV1 } from '../../src/clients/version1/PasswordsNullClientV1';
import { RolesMemoryClientV1 } from '../../src/clients/version1/RolesMemoryClientV1';
import { EmailSettingsMemoryClientV1 } from '../../src/clients/version1/EmailSettingsMemoryClientV1';
import { SitesMemoryClientV1 } from '../../src/clients/version1/SitesMemoryClientV1';

export class TestReferences extends ManagedReferences {
    private _factory = new ClientFacadeFactory();

    public constructor() {
        super();

        this.appendDependencies();
        this.configureService();
        this.createUsersAndSessions();
    }

    private appendDependencies() {
        // Add factories
        this.put(null, new ClientFacadeFactory());
        this.put(null, new DefaultRpcFactory());

        // Add service
        this.put(null, new FacadeServiceV1());
        this.put(null, new FacadeServiceV2());

        // Add services
        this.put(new Descriptor('pip-services-accounts', 'client', 'memory', 'default', '*'), new AccountsMemoryClientV1());
        this.put(new Descriptor('pip-services-sessions', 'client', 'memory', 'default', '*'), new SessionsMemoryClientV1());
        this.put(new Descriptor('pip-services-passwords', 'client', 'null', 'default', '*'), new PasswordsNullClientV1());
        this.put(new Descriptor('pip-services-roles', 'client', 'memory', 'default', '*'), new RolesMemoryClientV1());
        this.put(new Descriptor('pip-services-emailsettings', 'client', 'memory', 'default', '*'), new EmailSettingsMemoryClientV1());
        this.put(new Descriptor('pip-services-sites', 'client', 'direct', 'memory', '*'), new SitesMemoryClientV1());
    }

    private configureService(): void {
        // Configure Facade service
        let service = this.getOneRequired<HttpEndpoint>(
            new Descriptor('pip-services', 'endpoint', 'http', 'default', '*')
        );
        service.configure(ConfigParams.fromTuples(
            'root_path', '', //'/api/v1',
            'connection.protocol', 'http',
            'connection.host', 'localhost',
            'connection.port', 3000
        ));
    }

    private async createUsersAndSessions(): Promise<void> {
        // Create accounts
        let accountsClient = this.getOneRequired<IAccountsClientV1>(
            new Descriptor('pip-services-accounts', 'client', '*', '*', '*')
        );

        let adminUserAccount = <AccountV1>{
            id: TestUsers.AdminUserId, 
            login: TestUsers.AdminUserLogin, 
            name: TestUsers.AdminUserName,
            active: true,
            create_time: new Date()
        };
        await accountsClient.createAccount(null, adminUserAccount);

        let user1Account = <AccountV1>{
            id: TestUsers.User1Id, 
            login: TestUsers.User1Login, 
            name: TestUsers.User1Name,
            active: true,
            create_time: new Date()
        };
        await accountsClient.createAccount(null, user1Account);

        let user2Account = <AccountV1>{
            id: TestUsers.User2Id, 
            login: TestUsers.User2Login, 
            name: TestUsers.User2Name,
            active: true,
            create_time: new Date()
        };
        await accountsClient.createAccount(null, user2Account);

        // Create test site(s)
        let sitesClient = this.getOneRequired<ISitesClientV1>(
            new Descriptor('pip-services-sites', 'client', '*', '*', '*')
        );
        let site1 = <SiteV1>{
            id: TestSites.Site1Id, 
            name: TestSites.Site1Name
        };
        await sitesClient.createSite(null, site1);

        // Create user roles
        let rolesClient = this.getOneRequired<IRolesClientV1>(
            new Descriptor('pip-services-roles', 'client', '*', '*', '*')
        );
        await rolesClient.setRoles(
            null, TestUsers.AdminUserId, [ 'admin', TestSites.Site1Id + ':admin' ]);
        await rolesClient.setRoles(
            null, TestUsers.User1Id, [ TestSites.Site1Id + ':manager' ]);
        await rolesClient.setRoles(
            null, TestUsers.User2Id, [ TestSites.Site1Id + ':user' ]);

        // Create opened sessions
        let sessionsClient = this.getOneRequired<ISessionsClientV1>(
            new Descriptor('pip-services-sessions', 'client', '*', '*', '*')
        );

        let adminUserData: any = Object.assign({}, adminUserAccount);
        adminUserData.roles = [ 'admin', TestSites.Site1Id + ':admin' ];
        let session = await sessionsClient.openSession(
            null, TestUsers.AdminUserId, TestUsers.AdminUserName,
            null, null, adminUserData, null
        );

        session.id = TestUsers.AdminUserSessionId

        let user1Data: any = Object.assign({}, user1Account);
        user1Data.roles = [ TestSites.Site1Id + ':manager' ];
        session = await sessionsClient.openSession(
            null, TestUsers.User1Id, TestUsers.User1Name,
            null, null, user1Data, null
        );

        session.id = TestUsers.User1SessionId

        let user2Data: any = Object.assign({}, user2Account);
        user2Data.roles = [ TestSites.Site1Id + ':user' ];
        session = await sessionsClient.openSession(
            null, TestUsers.User2Id, TestUsers.User2Name,
            null, null, user2Data, null
        );

        session.id = TestUsers.User2SessionId
    }

}

package test_fixture

import (
	"context"
	"time"

	bclients1 "github.com/pip-services-samples/client-beacons-gox/clients/version1"
	fbuild "github.com/pip-services-samples/pip-samples-facade-go/build"
	operations1 "github.com/pip-services-samples/pip-samples-facade-go/operations/version1"
	services1 "github.com/pip-services-samples/pip-samples-facade-go/services/version1"
	accclients1 "github.com/pip-services-users/pip-clients-accounts-go/version1"
	passclients1 "github.com/pip-services-users/pip-clients-passwords-go/version1"
	roleclients1 "github.com/pip-services-users/pip-clients-roles-go/version1"
	sessclients1 "github.com/pip-services-users/pip-clients-sessions-go/version1"
	cbuild "github.com/pip-services4/pip-services4-go/pip-services4-components-go/build"
	cconf "github.com/pip-services4/pip-services4-go/pip-services4-components-go/config"
	cref "github.com/pip-services4/pip-services4-go/pip-services4-components-go/refer"
	bref "github.com/pip-services4/pip-services4-go/pip-services4-container-go/refer"
	rpcbuild "github.com/pip-services4/pip-services4-go/pip-services4-http-go/build"
	httpcontr "github.com/pip-services4/pip-services4-go/pip-services4-http-go/controllers"
)

type TestReferences struct {
	*bref.ManagedReferences

	factory *cbuild.CompositeFactory
}

func NewTestReferences() *TestReferences {
	c := TestReferences{
		ManagedReferences: bref.NewManagedReferences(context.Background(), nil),
		factory:           cbuild.NewCompositeFactory(),
	}

	c.setupFactories()
	c.appendDependencies()
	c.configureService()
	c.createUsersAndSessions()
	return &c
}

func (c *TestReferences) setupFactories() {
	c.factory.Add(fbuild.NewClientFacadeFactory())
	c.factory.Add(fbuild.NewServiceFacadeFactory())
	c.factory.Add(rpcbuild.NewDefaultHttpFactory())
}

func (c *TestReferences) Append(descriptor *cref.Descriptor) {
	component, err := c.factory.Create(descriptor)
	if err != nil {
		return
	}
	c.Put(context.Background(), descriptor, component)
}

func (c *TestReferences) appendDependencies() {
	// Add factories
	c.Put(context.Background(), nil, c.factory)

	// Add service
	c.Put(context.Background(), nil, services1.NewFacadeServiceV1())

	// Add user management services
	c.Put(context.Background(), cref.NewDescriptor("pip-services-accounts", "client", "memory", "default", "*"), accclients1.NewAccountsMemoryClientV1(nil))
	c.Put(context.Background(), cref.NewDescriptor("pip-services-sessions", "client", "memory", "default", "*"), sessclients1.NewSessionsMemoryClientV1())
	c.Put(context.Background(), cref.NewDescriptor("pip-services-passwords", "client", "commandable-http", "default", "*"), passclients1.NewPasswordsMemoryClientV1())
	c.Put(context.Background(), cref.NewDescriptor("pip-services-roles", "client", "commandable-http", "default", "*"), roleclients1.NewRolesMemoryClientV1())

	// Add content management services
	// Beacons
	c.Put(context.Background(), cref.NewDescriptor("beacons", "client", "memory", "default", "*"), bclients1.NewBeaconsMemoryClientV1(nil))
}

func (c *TestReferences) configureService() {
	// Configure Facade service
	dependency, _ := c.GetOneRequired(cref.NewDescriptor("pip-services", "endpoint", "http", "default", "*"))
	service, ok1 := dependency.(*httpcontr.HttpEndpoint)
	if !ok1 {
		panic("TestReferences: Cant't resolv dependency 'client' to IAccountsClientV1")
	}

	service.Configure(context.Background(), cconf.NewConfigParamsFromTuples(
		"root_path", "", //"/api/1.0",
		"connection.protocol", "http",
		"connection.host", "0.0.0.0",
		"connection.port", 3000,
	))

}

func (c *TestReferences) createUsersAndSessions() {
	// Create accounts
	dependency, _ := c.GetOneRequired(cref.NewDescriptor("pip-services-accounts", "client", "*", "*", "*"))
	accountsClient, ok1 := dependency.(accclients1.IAccountsClientV1)
	if !ok1 {
		panic("TestReferences: Cant't resolv dependency 'client' to IAccountsClientV1")
	}

	adminUserAccount := accclients1.AccountV1{
		Id:         TestUsers.AdminUserId,
		Login:      TestUsers.AdminUserLogin,
		Name:       TestUsers.AdminUserName,
		Active:     true,
		CreateTime: time.Time{},
	}
	accountsClient.CreateAccount("", &adminUserAccount)

	user1Account := accclients1.AccountV1{
		Id:         TestUsers.User1Id,
		Login:      TestUsers.User1Login,
		Name:       TestUsers.User1Name,
		Active:     true,
		CreateTime: time.Time{},
	}
	accountsClient.CreateAccount("", &user1Account)

	user2Account := accclients1.AccountV1{
		Id:         TestUsers.User2Id,
		Login:      TestUsers.User2Login,
		Name:       TestUsers.User2Name,
		Active:     true,
		CreateTime: time.Time{},
	}
	accountsClient.CreateAccount("", &user2Account)

	// Create opened sessions

	dependency, _ = c.GetOneRequired(cref.NewDescriptor("pip-services-sessions", "client", "*", "*", "*"))
	sessionsClient, ok2 := dependency.(sessclients1.ISessionsClientV1)
	if !ok2 {
		panic("TestReferences: Cant't resolv dependency 'client' to ISessionsClientV1")
	}

	adminUserData := c.cloneAccountToUserData(&adminUserAccount)
	adminUserData.Roles = []string{"admin"}
	session, _ := sessionsClient.OpenSession(
		"", TestUsers.AdminUserId, TestUsers.AdminUserName,
		"", "", adminUserData, nil)
	session.Id = TestUsers.AdminUserSessionId

	user1Data := c.cloneAccountToUserData(&user1Account)
	user1Data.Roles = make([]string, 0)

	session, _ = sessionsClient.OpenSession(
		"", TestUsers.User1Id, TestUsers.User1Name,
		"", "", user1Data, nil)
	session.Id = TestUsers.User1SessionId

	user2Data := c.cloneAccountToUserData(&user2Account)
	user2Data.Roles = make([]string, 0)
	session, _ = sessionsClient.OpenSession(
		"", TestUsers.User2Id, TestUsers.User2Name,
		"", "", user2Data, nil)
	session.Id = TestUsers.User2SessionId
}

func (c *TestReferences) cloneAccountToUserData(account *accclients1.AccountV1) *operations1.SessionUserV1 {
	if account == nil {
		return nil
	}
	return &operations1.SessionUserV1{
		Id:    account.Id,
		Login: account.Login,
		Name:  account.Name,

		/* Activity tracking */
		CreateTime: account.CreateTime,
		/* User preferences */
		TimeZone: account.TimeZone,
		Language: account.Language,
		Theme:    account.Theme,

		/* Custom fields */
		CustomHdr: account.CustomHdr,
		CustomDat: account.CustomDat,
	}
}

# -*- coding: utf-8 -*-
import datetime
from copy import deepcopy

from pip_services4_components.config.ConfigParams import ConfigParams
from pip_services4_components.refer.Descriptor import Descriptor
from pip_services4_container.refer.ManagedReferences import ManagedReferences
from pip_services4_http.build.DefaultRpcFactory import DefaultRpcFactory

from pip_facades_sample_python.build.ClientFacadeFactory import ClientFacadeFactory
from pip_facades_sample_python.clients.version1.AccountV1 import AccountV1
from pip_facades_sample_python.clients.version1.AccountsMemoryClientV1 import AccountsMemoryClientV1
from pip_facades_sample_python.clients.version1.EmailSettingsMemoryClientV1 import EmailSettingsMemoryClientV1
from pip_facades_sample_python.clients.version1.IAccountsClientV1 import IAccountsClientV1
from pip_facades_sample_python.clients.version1.IRolesClientV1 import IRolesClientV1
from pip_facades_sample_python.clients.version1.ISessionsClientV1 import ISessionsClientV1
from pip_facades_sample_python.clients.version1.ISitesClientV1 import ISitesClientV1
from pip_facades_sample_python.clients.version1.PasswordsNullClientV1 import PasswordsNullClientV1
from pip_facades_sample_python.clients.version1.RolesMemoryClientV1 import RolesMemoryClientV1
from pip_facades_sample_python.clients.version1.SessionsMemoryClientV1 import SessionsMemoryClientV1
from pip_facades_sample_python.clients.version1.SiteV1 import SiteV1
from pip_facades_sample_python.clients.version1.SitesMemoryClientV1 import SitesMemoryClientV1
from pip_facades_sample_python.controllers.version1.FacadeControllerV1 import FacadeControllerV1
from pip_facades_sample_python.controllers.version2.FacadeControllerV2 import FacadeControllerV2
from test.fixtures.TestSites import TestSites
from test.fixtures.TestUsers import TestUsers


class ReferencesTest(ManagedReferences):

    def __init__(self):
        super(ReferencesTest, self).__init__()
        self._factory = ClientFacadeFactory()

        self.__append_dependencies()
        self.__configure_controller()
        self.__create_user_and_sessions()

    def __append_dependencies(self):
        # Add factories
        self.put(None, ClientFacadeFactory())
        self.put(None, DefaultRpcFactory())

        # Add controller
        self.put(None, FacadeControllerV1())
        self.put(None, FacadeControllerV2())

        # Add controllers
        self.put(Descriptor('pip-services-accounts', 'client', 'memory', 'default', '*'), AccountsMemoryClientV1())
        self.put(Descriptor('pip-services-sessions', 'client', 'memory', 'default', '*'), SessionsMemoryClientV1())
        self.put(Descriptor('pip-services-passwords', 'client', 'null', 'default', '*'), PasswordsNullClientV1())
        self.put(Descriptor('pip-services-roles', 'client', 'memory', 'default', '*'), RolesMemoryClientV1())
        self.put(Descriptor('pip-services-emailsettings', 'client', 'memory', 'default', '*'),
                 EmailSettingsMemoryClientV1())
        self.put(Descriptor('pip-services-sites', 'client', 'direct', 'memory', '*'), SitesMemoryClientV1())

    def __configure_controller(self):
        # Configure Facade controller
        controller = self.get_one_required(Descriptor('pip-services', 'endpoint', 'http', 'default', '*'))

        controller.configure(ConfigParams.from_tuples(
            'root_path', '',  # '/api/v1',
            'connection.protocol', 'http',
            'connection.host', 'localhost',
            'connection.port', 3000
        ))

    def __create_user_and_sessions(self):
        # Create accounts
        accounts_client: IAccountsClientV1 = self.get_one_required(
            Descriptor('pip-services-accounts', 'client', '*', '*', '*'))

        admin_user_account = AccountV1(
            id=TestUsers.AdminUserId,
            login=TestUsers.AdminUserLogin,
            name=TestUsers.AdminUserName,
            active=True,
            create_time=datetime.datetime.now()
        )

        accounts_client.create_account(None, admin_user_account)

        user_1_account = AccountV1(
            id=TestUsers.User1Id,
            login=TestUsers.User1Login,
            name=TestUsers.User1Name,
            active=True,
            create_time=datetime.datetime.now()

        )

        accounts_client.create_account(None, user_1_account)

        user_2_account = AccountV1(
            id=TestUsers.User2Id,
            login=TestUsers.User2Login,
            name=TestUsers.User2Name,
            active=True,
            create_time=datetime.datetime.now()

        )

        accounts_client.create_account(None, user_2_account)

        # Create test site(s)
        sites_client: ISitesClientV1 = self.get_one_required(Descriptor('pip-services-sites', 'client', '*', '*', '*'))

        site1 = SiteV1(
            id=TestSites.Site1Id,
            name=TestSites.Site1Name
        )
        sites_client.create_site(None, site1)

        # Create user roles
        roles_client: IRolesClientV1 = self.get_one_required(Descriptor('pip-services-roles', 'client', '*', '*', '*'))

        roles_client.set_roles(None, TestUsers.AdminUserId, ['admin', TestSites.Site1Id + ':admin'])
        roles_client.set_roles(None, TestUsers.User1Id, [TestSites.Site1Id + ':manager'])
        roles_client.set_roles(None, TestUsers.User2Id, [TestSites.Site1Id + ':user'])

        # Create opened sessions
        sessions_client: ISessionsClientV1 = self.get_one_required(
            Descriptor('pip-services-sessions', 'client', '*', '*', '*'))

        admin_user_data = deepcopy(admin_user_account)
        admin_user_data.roles = ['admin', TestSites.Site1Id + ':admin']
        sessions_client.open_session(None, TestUsers.AdminUserId, TestUsers.AdminUserName,
                                     None, None, admin_user_data, None).id = TestUsers.AdminUserSessionId

        user_1_data = deepcopy(user_1_account)
        user_1_data.roles = [TestSites.Site1Id + ':manager']
        sessions_client.open_session(None, TestUsers.User1Id, TestUsers.User1Name,
                                     None, None, user_1_data, None, ).id = TestUsers.User1SessionId

        user_2_data = deepcopy(user_2_account)
        user_2_data.roles = [TestSites.Site1Id + ':manager']
        sessions_client.open_session(None, TestUsers.User2Id, TestUsers.User2Name,
                                     None, None, user_2_data, None, ).id = TestUsers.User2SessionId

import { ApplicationExceptionFactory, UnknownException } from "pip-services4-commons-node";

let restify = require('restify-clients');

export class TestRestClient {
    private _rest: any;

    public constructor() {
        let url = 'http://localhost:3000';
        this._rest = restify.createJsonClient({ url: url, version: '*', requestTimeout: 1500 });
    }

    protected async call(method: string, route: string, data?: any): Promise<any> {
        method = method.toLowerCase();

        return new Promise((resolve, reject) => {
            let action = (err, req, res, data) => {
                // Handling 204 codes
                if (res && res.statusCode == 204)
                    resolve(null);
                else if (err == null)
                    resolve(data);
                else {
                    // Restore application exception
                    if (data != null)
                        err = ApplicationExceptionFactory.create(data).withCause(err);
                    reject(err);
                }
            };

            if (method == 'get') this._rest.get(route, action);
            else if (method == 'head') this._rest.head(route, action);
            else if (method == 'post') this._rest.post(route, data, action);
            else if (method == 'put') this._rest.put(route, data, action);
            else if (method == 'patch') this._rest.patch(route, data, action);
            else if (method == 'delete' || method == 'del') this._rest.del(route, action);
            else {
                let err = new UnknownException('UNSUPPORTED_METHOD', 'Method is not supported by Test REST client'
                ).withDetails('verb', method);
                reject(err);
            }
        });
    }


    public async get(path: string): Promise<any> {
        delete this._rest.headers['x-session-id'];
        return await this.call('get', path);
    }

    public async head(path: string): Promise<any> {
        delete this._rest.headers['x-session-id'];
        return await this.call('head', path);
    }

    public async post(path: string, params: any): Promise<any> {
        delete this._rest.headers['x-session-id'];
        return await this.call('post', path, params);
    }

    public async put(path: string, params: any): Promise<any> {
        delete this._rest.headers['x-session-id'];
        return await this.call('put', path, params);
    }

    public async del(path: string): Promise<any> {
        delete this._rest.headers['x-session-id'];
        return await this.call('del', path);
    }


    public async getAsUser(sessionId: string, path: string): Promise<any> {
        this._rest.headers['x-session-id'] = sessionId;
        return await this.call('get', path);
    }

    public async headAsUser(sessionId: string, path: string): Promise<any> {
        this._rest.headers['x-session-id'] = sessionId;
        return await this.call('head', path);
    }

    public async postAsUser(sessionId: string, path: string, params: any): Promise<any> {
        this._rest.headers['x-session-id'] = sessionId;
        return await this.call('post', path, params);
    }

    public async putAsUser(sessionId: string, path: string, params: any): Promise<any> {
        this._rest.headers['x-session-id'] = sessionId;
        return await this.call('put', path, params);
    }

    public async delAsUser(sessionId: string, path: string, params?: any): Promise<any> {
        this._rest.headers['x-session-id'] = sessionId;
        return await this.call('del', path, params);
    }

}

package test_fixture

import (
	"bytes"
	"encoding/json"
	"io/ioutil"
	"net/http"
	"strings"

	cerr "github.com/pip-services4/pip-services4-go/pip-services4-commons-go/errors"
)

type TestRestClient struct {
	url string
}

func NewTestRestClient() *TestRestClient {
	c := TestRestClient{
		url: "http://localhost:3000",
	}
	return &c
}

func (c *TestRestClient) invoke(method string,
	route string, headers map[string]string, body interface{}, result interface{}) error {
	var url string = c.url + route

	method = strings.ToUpper(method)
	var bodyReader *bytes.Reader = bytes.NewReader(make([]byte, 0, 0))
	if body != nil {
		jsonBody, _ := json.Marshal(body)
		bodyReader = bytes.NewReader(jsonBody)
	}

	req, err := http.NewRequest(method, url, bodyReader)

	if err != nil {
		return err
	}
	// Set headers
	req.Header.Set("Accept", "application/json")
	if headers != nil && len(headers) > 0 {
		for k, v := range headers {
			req.Header.Set(k, v)
		}
	}
	client := http.Client{}
	response, respErr := client.Do(req)

	if respErr != nil {
		return respErr
	}

	if response.StatusCode == 204 {
		return nil
	}

	resBody, bodyErr := ioutil.ReadAll(response.Body)
	if bodyErr != nil {
		return bodyErr
	}

	if response.StatusCode >= 400 {
		appErr := cerr.ApplicationError{}
		json.Unmarshal(resBody, &appErr)
		return &appErr
	}

	if result == nil {
		return nil
	}

	jsonErr := json.Unmarshal(resBody, result)
	return jsonErr
}

func (c *TestRestClient) Get(path string, result interface{}) error {
	return c.invoke("get", path, nil, nil, result)
}

func (c *TestRestClient) Head(path string, result interface{}) error {
	return c.invoke("head", path, nil, nil, result)
}

func (c *TestRestClient) Post(path string, params interface{}, result interface{}) error {
	return c.invoke("post", path, nil, params, result)
}

func (c *TestRestClient) Put(path string, params interface{}, result interface{}) error {
	return c.invoke("put", path, nil, params, result)
}

func (c *TestRestClient) Del(path string, result interface{}) error {
	return c.invoke("delete", path, nil, nil, result)
}

func (c *TestRestClient) GetAsUser(sessionId string, path string, result interface{}) error {
	return c.invoke("get", path, map[string]string{"x-session-id": sessionId}, nil, result)
}

func (c *TestRestClient) HeadAsUser(sessionId string, path string, result interface{}) error {
	return c.invoke("head", path, map[string]string{"x-session-id": sessionId}, nil, result)
}

func (c *TestRestClient) PostAsUser(sessionId string, path string, params interface{}, result interface{}) error {
	return c.invoke("post", path, map[string]string{"x-session-id": sessionId}, params, result)
}

func (c *TestRestClient) PutAsUser(sessionId string, path string, params interface{}, result interface{}) error {
	return c.invoke("put", path, map[string]string{"x-session-id": sessionId}, params, result)
}

func (c *TestRestClient) DelAsUser(sessionId string, path string, result interface{}) error {
	return c.invoke("delete", path, map[string]string{"x-session-id": sessionId}, nil, result)
}

# -*- coding: utf-8 -*-

import requests


class RestClientTest:
    _rest = None
    headers = {'Content-type': 'application/json'}
    url = 'http://localhost:3000'

    def __init__(self):
        self._rest = requests.Session()

    def get(self, path):
        response = self._rest.request('GET', self.url + path, headers=self.headers)
        return response

    def head(self, path):
        response = self._rest.request('HEAD', self.url + path, headers=self.headers)
        return response

    def post(self, path, params):
        response = self._rest.request('POST', self.url + path, json=params, headers=self.headers)
        return response

    def put(self, path, params):
        response = self._rest.request('PUT', self.url + path, json=params, headers=self.headers)
        return response

    def delete(self, path, params=None):
        response = self._rest.request('DELETE', self.url + path, json=params, headers=self.headers)
        return response

    def get_as_user(self, session_id, path):
        self.headers.update({'x-session-id': session_id})
        # self._rest.request('GET', path, headers=self.headers)
        return self._rest.get(self.url + path, headers=self.headers)

    def head_as_user(self, session_id, path):
        self.headers.update({'x-session-id': session_id})
        return self._rest.head(self.url + path, headers=self.headers)

    def post_as_user(self, session_id, path, params):
        self.headers.update({'x-session-id': session_id})
        return self._rest.post(self.url + path, json=params, headers=self.headers)

    def put_as_user(self, session_id, path, params):
        self.headers.update({'x-session-id': session_id})
        return self._rest.put(self.url + path, json=params, headers=self.headers)

    def delete_as_user(self, session_id, path):
        self.headers.update({'x-session-id': session_id})
        return self._rest.delete(self.url + path, headers=self.headers)

export class TestUsers {
    public static readonly AdminUserId: string = '1';
    public static readonly AdminUserName: string = 'Admin User';
    public static readonly AdminUserLogin: string = 'admin';
    public static readonly AdminUserPassword: string = 'pwd123';
    public static readonly AdminUserSessionId: string = '111';

    public static readonly User1Id: string = '2';
    public static readonly User1Name: string = 'User #1';
    public static readonly User1Login: string = 'user1';
    public static readonly User1Password: string = 'pwd123';
    public static readonly User1SessionId: string = '222';

    public static readonly User2Id: string = '3';
    public static readonly User2Name: string = 'User #2';
    public static readonly User2Login: string = 'user2';
    public static readonly User2Password: string = 'pwd123';
    public static readonly User2SessionId: string = '333';
};

package test_fixture

var TestUsers tTestUsers = NewTTestUsers()

type tTestUsers struct {
	AdminUserId        string
	AdminUserName      string
	AdminUserLogin     string
	AdminUserPassword  string
	AdminUserSessionId string

	User1Id        string
	User1Name      string
	User1Login     string
	User1Password  string
	User1SessionId string

	User2Id        string
	User2Name      string
	User2Login     string
	User2Password  string
	User2SessionId string
}

func NewTTestUsers() tTestUsers {
	c := tTestUsers{
		AdminUserId:        "1",
		AdminUserName:      "Admin User",
		AdminUserLogin:     "admin",
		AdminUserPassword:  "pwd123",
		AdminUserSessionId: "111",

		User1Id:        "2",
		User1Name:      "User #1",
		User1Login:     "user1",
		User1Password:  "pwd123",
		User1SessionId: "222",

		User2Id:        "3",
		User2Name:      "User #2",
		User2Login:     "user2",
		User2Password:  "pwd123",
		User2SessionId: "333",
	}
	return c
}

# -*- coding: utf-8 -*-

class TestUsers:
    AdminUserId: str = '1'
    AdminUserName: str = 'Admin User'
    AdminUserLogin: str = 'admin'
    AdminUserPassword: str = 'pwd123'
    AdminUserSessionId: str = '111'
    User1Id: str = '2'
    User1Name: str = 'User #1'
    User1Login: str = 'user1'
    User1Password: str = 'pwd123'
    User1SessionId: str = '222'
    User2Id: str = '3'
    User2Name: str = 'User #2'
    User2Login: str = 'user2'
    User2Password: str = 'pwd123'
    User2SessionId: str = '333'

const assert = require('chai').assert;

import { DataPage } from 'pip-services4-data-node';
import { Descriptor } from 'pip-services4-components-node';

import { BeaconV1 } from '../../../src/clients/version1/BeaconV1';
import { BeaconsMemoryClientV1 } from '../../../src/clients/version1/BeaconsMemoryClientV1';

import { TestUsers } from '../../fixtures/TestUsers';
import { TestReferences } from '../../fixtures/TestReferences';
import { TestRestClient } from '../../fixtures/TestRestClient';

let BEACON1: BeaconV1 = {
    id: '1',
    udi: '000001',
    site_id: '1',
    label: 'TestBeacon1',
    center: { type: 'Point', coordinates: [0, 0] },
    radius: 50
};
let BEACON2: BeaconV1 = {
    id: '2',
    udi: '000002',
    site_id: '1',
    label: 'TestBeacon2',
    center: { type: 'Point', coordinates: [2, 2] },
    radius: 70
};
let BEACON3: BeaconV1 = {
    id: '3',
    udi: '000003',
    site_id: '2',
    label: 'TestBeacon3',
    center: { type: 'Point', coordinates: [10, 10] },
    radius: 50
};

suite('BeaconsOperationsV1', () => {
    let references: TestReferences;
    let rest: TestRestClient;

    setup(async () => {
        rest = new TestRestClient();
        references = new TestReferences();
        references.put(new Descriptor('beacons', 'client', 'memory', 'default', '1.0'), new BeaconsMemoryClientV1());
        await references.open(null);
    });

    teardown(async () => {
        await references.close(null);
    });

    test('should perform beacon operations', async () => {
        let beacon1, beacon2, beacon3: BeaconV1;
        // Create one beacon
        let beacon = await rest.postAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + BEACON1.site_id + '/beacons',
            BEACON1,
        );

        assert.isObject(beacon);
        assert.equal(beacon.site_id, BEACON1.site_id);
        assert.equal(beacon.udi, BEACON1.udi);
        assert.equal(beacon.label, BEACON1.label);
        assert.isNotNull(beacon.center);

        beacon1 = beacon;


        // Create another beacon
        beacon = await rest.postAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + BEACON2.site_id + '/beacons',
            BEACON2
        );

        assert.isObject(beacon);
        assert.equal(beacon.site_id, BEACON2.site_id);
        assert.equal(beacon.udi, BEACON2.udi);
        assert.equal(beacon.label, BEACON2.label);
        assert.isNotNull(beacon.center);

        beacon2 = beacon;

        // Create yet another beacon
        beacon = await rest.postAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + BEACON3.site_id + '/beacons',
            BEACON3
        );

        assert.isObject(beacon);
        assert.equal(beacon.site_id, BEACON3.site_id);
        assert.equal(beacon.udi, BEACON3.udi);
        assert.equal(beacon.label, BEACON3.label);
        assert.isNotNull(beacon.center);

        beacon3 = beacon;

        // Get all beacons
        let page: DataPage<BeaconV1> = await rest.getAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + BEACON1.site_id + '/beacons'
        );
        
        assert.isObject(page);
        assert.lengthOf(page.data, 2);

        // Calculate positions
        let position = await rest.postAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + BEACON1.site_id + '/beacons/calculate_position',
            {
                site_id: BEACON1.site_id,
                udis: [BEACON1.udi]
            }
        );

        assert.isObject(position);
        assert.equal(position.type, 'Point');

        // Validate beacon udi
        let result = await rest.postAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + beacon1.site_id + '/beacons/validate_udi?udi=' + beacon1.udi,
            {},
        );

        assert.equal(result, beacon1.id);

        // Update the beacon
        beacon1.label = 'ABC';

        beacon = await rest.putAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + beacon1.site_id + '/beacons/' + beacon1.id,
            beacon1
        );

        assert.isObject(beacon);
        assert.equal(beacon.label, 'ABC');

        // Delete beacon
        beacon = await rest.delAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + beacon1.site_id + '/beacons/' + beacon1.id
        );

        assert.equal(beacon.id, beacon1.id);

        // Try to get delete beacon
        result = await rest.getAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sites/' + beacon1.site_id + '/beacons/' + beacon1.id
        );

        assert.isNull(result);
    });

});

package test_operations

import (
	"context"
	"testing"

	testfixture "github.com/pip-services-samples/pip-samples-facade-go/test/fixture"
	data1 "github.com/pip-services-samples/service-beacons-gox/data/version1"
	cdata "github.com/pip-services4/pip-services4-go/pip-services4-commons-go/data"
	"github.com/stretchr/testify/assert"
)

type beaconsRestServiceV1Test struct {
	BEACON1    *data1.BeaconV1
	BEACON2    *data1.BeaconV1
	references *testfixture.TestReferences
	rest       *testfixture.TestRestClient
}

func newBeaconsRestServiceV1Test() *beaconsRestServiceV1Test {
	BEACON1 := &data1.BeaconV1{
		Id:     "1",
		Udi:    "00001",
		Type:   data1.AltBeacon,
		SiteId: "1",
		Label:  "TestBeacon1",
		Center: data1.GeoPointV1{Type: "Point", Coordinates: [][]float32{{0.0, 0.0}}},
		Radius: 50,
	}

	BEACON2 := &data1.BeaconV1{
		Id:     "2",
		Udi:    "00002",
		Type:   data1.IBeacon,
		SiteId: "1",
		Label:  "TestBeacon2",
		Center: data1.GeoPointV1{Type: "Point", Coordinates: [][]float32{{2.0, 2.0}}},
		Radius: 70,
	}

	return &beaconsRestServiceV1Test{
		BEACON1: BEACON1,
		BEACON2: BEACON2,
	}
}

func (c *beaconsRestServiceV1Test) setup(t *testing.T) {
	c.rest = testfixture.NewTestRestClient()
	c.references = testfixture.NewTestReferences()
	err := c.references.Open(context.Background())
	if err != nil {
		t.Error("Failed to open references", err)
	}
}

func (c *beaconsRestServiceV1Test) teardown(t *testing.T) {
	c.rest = nil
	err := c.references.Close(context.Background())
	if err != nil {
		t.Error("Failed to close references", err)
	}
}

func (c *beaconsRestServiceV1Test) testCrudOperations(t *testing.T) {
	var beacon1 *data1.BeaconV1

	var beacon data1.BeaconV1

	err := c.rest.PostAsUser(testfixture.TestUsers.AdminUserSessionId, "/api/v1/beacons", c.BEACON1, &beacon)
	assert.Nil(t, err)
	assert.NotNil(t, beacon)
	assert.Equal(t, c.BEACON1.Udi, beacon.Udi)
	assert.Equal(t, c.BEACON1.SiteId, beacon.SiteId)
	assert.Equal(t, c.BEACON1.Type, beacon.Type)
	assert.Equal(t, c.BEACON1.Label, beacon.Label)
	assert.NotNil(t, beacon.Center)

	err = c.rest.PostAsUser(testfixture.TestUsers.AdminUserSessionId, "/api/v1/beacons", c.BEACON2, &beacon)
	assert.Nil(t, err)
	assert.NotNil(t, beacon)
	assert.Equal(t, c.BEACON2.Udi, beacon.Udi)
	assert.Equal(t, c.BEACON2.SiteId, beacon.SiteId)
	assert.Equal(t, c.BEACON2.Type, beacon.Type)
	assert.Equal(t, c.BEACON2.Label, beacon.Label)
	assert.NotNil(t, beacon.Center)

	var page data1.BeaconV1DataPage
	err = c.rest.GetAsUser(testfixture.TestUsers.AdminUserSessionId, "/api/v1/beacons", &page)
	assert.Nil(t, err)
	assert.NotNil(t, page)
	assert.Len(t, page.Data, 2)
	beacon1 = page.Data[0]

	// Update the beacon
	beacon1.Label = "ABC"
	err = c.rest.PutAsUser(testfixture.TestUsers.AdminUserSessionId, "/api/v1/beacons", beacon1, &beacon)
	assert.Nil(t, err)
	assert.NotNil(t, beacon)
	assert.Equal(t, beacon1.Id, beacon.Id)
	assert.Equal(t, "ABC", beacon.Label)

	err = c.rest.GetAsUser(testfixture.TestUsers.User1SessionId, "/api/v1/beacons/udi/"+beacon1.Udi+"?user_id="+testfixture.TestUsers.User1Id, &beacon)
	assert.Nil(t, err)
	assert.NotNil(t, beacon)
	assert.Equal(t, beacon1.Id, beacon.Id)

	//Calculate position for one beacon
	body := cdata.NewAnyValueMapFromTuples(
		"site_id", "1",
		"udis", []string{"00001"},
	)
	var position data1.GeoPointV1
	err = c.rest.PostAsUser(testfixture.TestUsers.User1SessionId, "/api/v1/beacons/position", body.Value(), &position)
	assert.Nil(t, err)
	assert.NotNil(t, position)
	assert.Equal(t, "Point", position.Type)
	assert.Equal(t, (float32)(0.0), position.Coordinates[0][0])
	assert.Equal(t, (float32)(0.0), position.Coordinates[0][1])

	err = c.rest.DelAsUser(testfixture.TestUsers.AdminUserSessionId, "/api/v1/beacons/"+beacon1.Id, &beacon)
	assert.Nil(t, err)
	assert.NotNil(t, beacon)
	assert.Equal(t, beacon1.Id, beacon.Id)

	beacon = data1.BeaconV1{}
	err = c.rest.GetAsUser(testfixture.TestUsers.User1SessionId, "/api/v1/beacons/"+beacon1.Id+"?user_id="+testfixture.TestUsers.User1Id, &beacon)
	assert.Nil(t, err)
	assert.NotNil(t, beacon)
	assert.Empty(t, beacon)
}

func TestBeaconsRestServiceV1(t *testing.T) {
	c := newBeaconsRestServiceV1Test()

	c.setup(t)
	t.Run("CRUD Operations", c.testCrudOperations)
	c.teardown(t)

}

# -*- coding: utf-8 -*-

from pip_services4_commons.convert import JsonConverter, TypeCode
from pip_services4_components.refer import Descriptor

from pip_facades_sample_python.clients.version1.BeaconV1 import BeaconV1
from pip_facades_sample_python.clients.version1.BeaconsMemoryClientV1 import BeaconsMemoryClientV1
from test.fixtures.ReferencesTest import ReferencesTest
from test.fixtures.RestClientTest import RestClientTest
from test.fixtures.TestUsers import TestUsers

BEACON1 = BeaconV1(id="1",
                   site_id="1",
                   udi="00001",
                   label="TestBeacon1",
                   center={"type": 'Point', "coordinates": [0, 0]},
                   radius=50)

BEACON2 = BeaconV1(id="2",
                   site_id="1",
                   udi="00002",
                   label="TestBeacon2",
                   center={"type": 'Point', "coordinates": [2, 2]},
                   radius=70)

BEACON3 = BeaconV1(id="3",
                   site_id="2",
                   udi="00003",
                   label="TestBeacon3",
                   center={"type": 'Point', "coordinates": [10, 10]},
                   radius=50)


class TestBeaconsOperationsV1:
    references: ReferencesTest = None
    rest: RestClientTest = None

    @classmethod
    def setup_class(cls):
        cls.rest = RestClientTest()
        cls.references = ReferencesTest()
        cls.references.put(Descriptor('beacons', 'client', 'memory', 'default', '1.0'),
                           BeaconsMemoryClientV1())

        cls.references.open(None)

    @classmethod
    def teardown_class(cls):
        cls.references.close(None)

    def test_beacons_operations(self):
        # Create one beacon
        response = self.rest.post_as_user(TestUsers.AdminUserSessionId,
                                          '/api/v1/sites/' + BEACON1.site_id + '/beacons',
                                          JsonConverter.to_json(BEACON1))

        created_beacon = JsonConverter.from_json(TypeCode.Map, response.content)
        beacon1 = created_beacon

        assert response.status_code < 300
        assert BEACON1.udi == created_beacon['udi']
        assert BEACON1.id == created_beacon['id']
        assert BEACON1.site_id == created_beacon['site_id']
        assert created_beacon['center'] is not None

        # Create the second beacon
        response = self.rest.post_as_user(TestUsers.AdminUserSessionId,
                                          '/api/v1/sites/' + BEACON2.site_id + '/beacons',
                                          JsonConverter.to_json(BEACON2))
        assert response.status_code < 300

        created_beacon = JsonConverter.from_json(TypeCode.Map, response.content)
        assert BEACON2.udi == created_beacon['udi']
        assert BEACON2.id == created_beacon['id']
        assert BEACON2.site_id == created_beacon['site_id']
        assert created_beacon['center'] is not None

        # Create yet another beacon
        response = self.rest.post_as_user(TestUsers.AdminUserSessionId,
                                          '/api/v1/sites/' + BEACON3.site_id + '/beacons',
                                          JsonConverter.to_json(BEACON3))
        assert response.status_code < 300

        created_beacon = JsonConverter.from_json(TypeCode.Map, response.content)
        assert BEACON3.udi == created_beacon['udi']
        assert BEACON3.id == created_beacon['id']
        assert BEACON3.site_id == created_beacon['site_id']
        assert created_beacon['center'] is not None

        # Get all beacons
        response = self.rest.get_as_user(TestUsers.AdminUserSessionId,
                                         '/api/v1/sites/' + BEACON1.site_id + '/beacons', )
        beacons = JsonConverter.from_json(TypeCode.Map, response.content)
        assert len(beacons['data']) == 2

        # Calculate position for one beacon
        response = self.rest.post_as_user(TestUsers.AdminUserSessionId,
                                          '/api/v1/sites/' + BEACON1.site_id + '/beacons/calculate_position', {
                                              'site_id': BEACON1.site_id,
                                              'udis': [BEACON1.udi]
                                          })

        calc_position = JsonConverter.from_json(TypeCode.Map, response.content)

        assert response.status_code < 300
        assert calc_position['type'] == 'Point'
        assert len(calc_position['coordinates']) == 2

        # Validate beacon udi
        response = self.rest.post_as_user(TestUsers.AdminUserSessionId,
                                          '/api/v1/sites/' + beacon1['site_id'] + '/beacons/validate_udi?udi=' +
                                          beacon1['udi'],
                                          {}, )
        assert JsonConverter.from_json(TypeCode.Map, response.content)['id'] == beacon1['id']

        # Update the beacon
        BEACON1.label = 'ABC'
        response = self.rest.put_as_user(TestUsers.AdminUserSessionId,
                                         '/api/v1/sites/' + beacon1['site_id'] + '/beacons/' + beacon1['id'],
                                         JsonConverter.to_json(BEACON1))

        updated_beacon = JsonConverter.from_json(TypeCode.Map, response.content)
        beacon1 = updated_beacon

        assert response.status_code < 300
        assert BEACON1.id == updated_beacon['id']
        assert updated_beacon['label'] == 'ABC'

        # Delete the beacon
        response = self.rest.delete_as_user(TestUsers.AdminUserSessionId,
                                            '/api/v1/sites/' + beacon1['site_id'] + '/beacons/' + beacon1['id'])
        deleted_result = JsonConverter.from_json(TypeCode.Map, response.content)
        assert deleted_result['id'] == BEACON1.id

        # Try to get deleted beacon
        response = self.rest.get_as_user(TestUsers.AdminUserSessionId,
                                         '/api/v1/sites/' + beacon1['site_id'] + '/beacons/' + beacon1['id'], )
        assert response.status_code == 204

const assert = require('chai').assert;

import { TestReferences } from '../../fixtures/TestReferences';
import { TestUsers } from '../../fixtures/TestUsers';
import { TestRestClient } from '../../fixtures/TestRestClient';

suite('SessionRoutesV1', () => {
    let USER = {
        login: 'test',
        name: 'Test User',
        email: 'test@conceptual.vision',
        password: 'test123'
    };

    let references: TestReferences;
    let rest: TestRestClient;

    setup(async () => {
        rest = new TestRestClient();
        references = new TestReferences();
        await references.open(null);
    });

    teardown(async () => {
        await references.close(null);
    });

    test('should signup new user', async () => {

        let session = await rest.post('/api/v1/signup', USER);
        assert.isNotNull(session);

        assert.isDefined(session);
        assert.isDefined(session.id);
        assert.equal(session.user_name, USER.name);
    });

    test('should check login for signup', async () => {

        // Check registered email
        let err = null;
        try {
            await rest.get('/api/v1/signup/validate?login=' + TestUsers.User1Login)
        } catch (ex) {
            err = ex;
        }
        assert.isNotNull(err);


        // Check not registered email
        await rest.get('/api/v1/signup/validate?login=xxx@gmail.com');

    });

    test('should not signup with the same email', async () => {

        // Sign up
        await rest.post('/api/v1/signup', USER);

        // Try to sign up again
        let err = null;
        try {
            await rest.post('/api/v1/signup', USER);
        } catch (ex) {
            err = ex;
        }
        assert.isNotNull(err);

    });

    test('should signout', async () => {
        await rest.post('/api/v1/signout', null);
    });

    test('should signin with email and password', async () => {

        // Sign up
        await rest.post('/api/v1/signup', USER);

        // Sign in with username
        await rest.post('/api/v1/signin',
            {
                login: USER.login,
                password: USER.password
            }
        );

    });
    
    test('should get sessions as admin', async () => {
        let page = await rest.getAsUser(
            TestUsers.AdminUserSessionId,
            '/api/v1/sessions?paging=1&skip=0&take=2',
        );

        assert.isObject(page);

    });

    test('should get user sessions as owner', async () => {
        let page = await rest.getAsUser(
            TestUsers.User1SessionId,
            '/api/v1/sessions/' + TestUsers.User1Id + '?paging=1&skip=0&take=2'
        );

        assert.isObject(page);
    });

    test('should restore user sessions as owner', async () => {
        let session = await rest.postAsUser(
            TestUsers.User1SessionId,
            '/api/v1/sessions/restore?session_id=' + TestUsers.User1SessionId,
            {}
        );

        assert.isObject(session);
    });

});

package test_operations

import (
	"context"
	"testing"

	testfixture "github.com/pip-services-samples/pip-samples-facade-go/test/fixture"
	"github.com/stretchr/testify/assert"
)

type sessionRoutesV1Test struct {
	references *testfixture.TestReferences
	rest       *testfixture.TestRestClient
	user       map[string]string
}

func newSessionRoutesV1Test() *sessionRoutesV1Test {
	c := &sessionRoutesV1Test{
		user: make(map[string]string, 0),
	}

	c.user["login"] = "test"
	c.user["name"] = "Test User"
	c.user["email"] = "test@conceptual.vision"
	c.user["password"] = "test123"

	return c
}

func (c *sessionRoutesV1Test) setup(t *testing.T) {
	c.rest = testfixture.NewTestRestClient()
	c.references = testfixture.NewTestReferences()
	err := c.references.Open(context.Background())
	if err != nil {
		t.Error("Failed to open references", err)
	}
}

func (c *sessionRoutesV1Test) teardown(t *testing.T) {
	c.rest = nil
	err := c.references.Close(context.Background())
	if err != nil {
		t.Error("Failed to close references", err)
	}
}

func (c *sessionRoutesV1Test) testSignupNewUser(t *testing.T) {

	session := make(map[string]interface{})
	err := c.rest.Post("/api/v1/users/signup", c.user, &session)

	assert.Nil(t, err)
	assert.NotNil(t, session)
	assert.NotNil(t, session["id"])
	assert.Equal(t, session["user_name"], c.user["name"])
}

func (c *sessionRoutesV1Test) testNotSignupWithTheSameEmail(t *testing.T) {

	// Sign up
	session := make(map[string]interface{})
	err := c.rest.Post("/api/v1/users/signup", c.user, &session)
	assert.Nil(t, err)
	// Try to sign up again
	err = c.rest.Post("/api/v1/users/signup", c.user, &session)
	assert.NotNil(t, err)
}

func (c *sessionRoutesV1Test) testShouldSignout(t *testing.T) {
	result := make(map[string]interface{})
	err := c.rest.Post("/api/v1/users/signout", nil, &result)
	assert.Nil(t, err)
}

func (c *sessionRoutesV1Test) testShouldSigninWithEmailAndPassword(t *testing.T) {

	// Sign up
	session := make(map[string]interface{})
	err := c.rest.Post("/api/v1/users/signup",
		c.user, &session)
	assert.Nil(t, err)

	// Sign in with username
	err = c.rest.Post("/api/v1/users/signin",
		map[string]string{
			"login":    c.user["login"],
			"password": c.user["password"],
		}, &session)
	assert.Nil(t, err)
}

func TestSignupNewUser(t *testing.T) {
	c := newSessionRoutesV1Test()

	c.setup(t)
	t.Run("Signup New User", c.testSignupNewUser)
	c.teardown(t)
}

func TestNotSignupWithTheSameEmail(t *testing.T) {
	c := newSessionRoutesV1Test()
	c.setup(t)
	t.Run("Not Signup With The Same Email", c.testNotSignupWithTheSameEmail)
	c.teardown(t)
}
func TestShouldSignout(t *testing.T) {
	c := newSessionRoutesV1Test()
	c.setup(t)
	t.Run("Should Signout", c.testShouldSignout)
	c.teardown(t)

}
func TestShouldSigninWithEmailAndPassword(t *testing.T) {
	c := newSessionRoutesV1Test()
	c.setup(t)
	t.Run("Should Signin With Email And Password", c.testShouldSigninWithEmailAndPassword)
	c.teardown(t)
}