WIP #55: added tests for NamespaceHttp.getLinkedX and Alias/AddressAlias/MosaicAlias/EmptyAlias classes

Author: Greg S

e2e/infrastructure/NamespaceHttp.spec.ts

@@ -69,4 +69,24 @@ describe('NamespaceHttp', () => {
                 });
         });
     });
+
+    describe('getLinkedMosaicId', () => {
+        it('should return mosaicId given namespaceId', (done) => {
+            namespaceHttp.getLinkedMosaicId(namespaceId)
+                .subscribe((mosaicId) => {
+                    expect(mosaicId).to.be.null;
+                    done();
+                });
+        });
+    });
+
+    describe('getLinkedAddress', () => {
+        it('should return address given namespaceId', (done) => {
+            namespaceHttp.getLinkedAddress(namespaceId)
+                .subscribe((address) => {
+                    expect(address).to.be.null;
+                    done();
+                });
+        });
+    });
 });

src/infrastructure/NamespaceHttp.ts

@@ -167,13 +167,13 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
 
     /**
      * Gets the MosaicId from a MosaicAlias
-     * @param alias - String containing the address alias
+     * @param namespaceId - the namespaceId of the namespace
      * @returns Observable<MosaicId | null>
      */
-    public getLinkedMosaicId(alias: string): Observable<MosaicId | null> {
+    public getLinkedMosaicId(namespaceId: NamespaceId): Observable<MosaicId | null> {
         return this.getNetworkTypeObservable().pipe(
             mergeMap((networkType) => observableFrom(
-                this.namespaceRoutesApi.getNamespace(alias)).pipe(
+                this.namespaceRoutesApi.getNamespace(namespaceId.toHex())).pipe(
                 map((namespaceInfoDTO) => {
 
                     if (namespaceInfoDTO.namespace.alias.type === AliasType.Mosaic) {
@@ -186,13 +186,13 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
 
     /**
      * Gets the Address from a AddressAlias
-     * @param alias - String containing the address alias
+     * @param namespaceId - the namespaceId of the namespace
      * @returns Observable<Address>
      */
-    public getLinkedAddress(alias: string): Observable<Address | null> {
+    public getLinkedAddress(namespaceId: NamespaceId): Observable<Address | null> {
         return this.getNetworkTypeObservable().pipe(
             mergeMap((networkType) => observableFrom(
-                this.namespaceRoutesApi.getNamespace(alias)).pipe(
+                this.namespaceRoutesApi.getNamespace(namespaceId.toHex())).pipe(
                 map((namespaceInfoDTO) => {
 
                     if (namespaceInfoDTO.namespace.alias.type === AliasType.Address) {

src/infrastructure/NamespaceRepository.ts

@@ -64,15 +64,15 @@ export interface NamespaceRepository {
 
     /**
      * Gets the MosaicId from a MosaicAlias
-     * @param alias - String containing the address alias
+     * @param namespaceId - the namespaceId of the namespace
      * @returns Observable<MosaicId | null>
      */
-    getLinkedMosaicId(alias: string): Observable<MosaicId | null>;
+    getLinkedMosaicId(namespaceId: NamespaceId): Observable<MosaicId | null>;
 
     /**
      * Gets the Address from a AddressAlias
-     * @param alias - String containing the address alias
+     * @param namespaceId - the namespaceId of the namespace
      * @returnsObservable<Address | null>
      */
-    getLinkedAddress(alias: string): Observable<Address | null>;
+    getLinkedAddress(namespaceId: NamespaceId): Observable<Address | null>;
 }

test/model/namespace/Alias.spec.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2018 NEM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {deepEqual} from 'assert';
+import {expect} from 'chai';
+import {Address} from '../../../src/model/account/Address';
+import {NetworkType} from '../../../src/model/blockchain/NetworkType';
+import {MosaicId} from '../../../src/model/mosaic/MosaicId';
+import {AddressAlias} from '../../../src/model/namespace/AddressAlias';
+import {Alias} from '../../../src/model/namespace/Alias';
+import {AliasType} from '../../../src/model/namespace/AliasType';
+import {EmptyAlias} from '../../../src/model/namespace/EmptyAlias';
+import {MosaicAlias} from '../../../src/model/namespace/MosaicAlias';
+import {UInt64} from '../../../src/model/UInt64';
+
+describe('Alias', () => {
+    let emptyAliasDTO;
+    let addressAliasDTO;
+    let mosaicAliasDTO;
+    let address;
+    let address2;
+
+    before(() => {
+        address = Address.createFromRawAddress('SCTVW23D2MN5VE4AQ4TZIDZENGNOZXPRPRLIKCF2');
+        address2 = Address.createFromRawAddress('SARNASAS2BIAB6LMFA3FPMGBPGIJGK6IJETM3ZSP');
+        emptyAliasDTO = {
+            type: 0,
+        };
+        mosaicAliasDTO = {
+            type: AliasType.Mosaic,
+            mosaicId: new MosaicId([481110499, 231112638]),
+        };
+        addressAliasDTO = {
+            type: AliasType.Address,
+            address,
+        };
+    });
+
+    it('should create an EmptyAlias object', () => {
+        const alias = new EmptyAlias();
+        expect(alias.type).to.be.equal(AliasType.None);
+    });
+
+    it('should create a AddressAlias object', () => {
+        const alias = new AddressAlias(addressAliasDTO.type, addressAliasDTO.address);
+        expect(alias.type).to.be.equal(AliasType.Address);
+        expect(alias.address).to.be.equal(addressAliasDTO.address);
+    });
+
+    it('should create a MosaicAlias object', () => {
+        const alias = new MosaicAlias(mosaicAliasDTO.type, mosaicAliasDTO.mosaicId);
+        expect(alias.type).to.be.equal(AliasType.Mosaic);
+        expect(alias.mosaicId).to.be.equal(mosaicAliasDTO.mosaicId);
+    });
+
+    it('should compare addresses in AddressAlias.equals()', () => {
+        const alias1 = new AddressAlias(addressAliasDTO.type, addressAliasDTO.address);
+        const alias2 = new AddressAlias(addressAliasDTO.type, addressAliasDTO.address);
+        const alias3 = new AddressAlias(addressAliasDTO.type, address2);
+
+        expect(alias1.equals(alias2)).to.be.equal(true);
+        expect(alias1.equals(alias3)).to.be.equal(false);
+    });
+
+    it('should compare mosaicIds in MosaicAlias.equals()', () => {
+        const alias1 = new MosaicAlias(mosaicAliasDTO.type, mosaicAliasDTO.mosaicId);
+        const alias2 = new MosaicAlias(mosaicAliasDTO.type, mosaicAliasDTO.mosaicId);
+        const alias3 = new MosaicAlias(mosaicAliasDTO.type, new MosaicId([481110498, 231112637]));
+
+        expect(alias1.equals(alias2)).to.be.equal(true);
+        expect(alias1.equals(alias3)).to.be.equal(false);
+    });
+});

test/model/namespace/NamespaceInfo.spec.ts

@@ -18,6 +18,7 @@ import {deepEqual} from 'assert';
 import {expect} from 'chai';
 import {PublicAccount} from '../../../src/model/account/PublicAccount';
 import {NetworkType} from '../../../src/model/blockchain/NetworkType';
+import {MosaicId} from '../../../src/model/mosaic/MosaicId';
 import {NamespaceId} from '../../../src/model/namespace/NamespaceId';
 import {NamespaceInfo} from '../../../src/model/namespace/NamespaceInfo';
 import {UInt64} from '../../../src/model/UInt64';
@@ -41,7 +42,7 @@ describe('NamespaceInfo', () => {
                 parentId: new NamespaceId([0, 0]),
                 startHeight: new UInt64([1, 0]),
                 type: 0,
-                alias: {type: 0},
+                alias: {type: 1, mosaicId: new MosaicId([481110499, 231112638])},
             },
         };
         subNamespaceDTO = {
@@ -90,7 +91,8 @@ describe('NamespaceInfo', () => {
         expect(namespaceInfo.owner.publicKey).to.be.equal(rootNamespaceDTO.namespace.owner);
         deepEqual(namespaceInfo.startHeight, rootNamespaceDTO.namespace.startHeight);
         deepEqual(namespaceInfo.endHeight, rootNamespaceDTO.namespace.endHeight);
-        deepEqual(namespaceInfo.alias, rootNamespaceDTO.namespace.alias);
+        expect(namespaceInfo.alias.type).to.be.equal(rootNamespaceDTO.namespace.alias.type);
+        expect(namespaceInfo.alias.mosaicId).to.be.equal(rootNamespaceDTO.namespace.alias.mosaicId);
     });
 
     it('should return the NamespaceId in string format', () => {
@@ -146,6 +148,16 @@ describe('NamespaceInfo', () => {
         expect(namespaceInfo.id).to.be.equal(subNamespaceDTO.namespace.level1);
     });
 
+    it('hasAlias() should return false when the Namespace alias has type 1', () => {
+        const namespaceInfo = createRootFromDTO(rootNamespaceDTO);
+        expect(namespaceInfo.hasAlias()).to.be.equal(true);
+    });
+
+    it('hasAlias() should return false when the Namespace alias has type 0', () => {
+        const namespaceInfo = createSubnamespaceFromDTO(subNamespaceDTO);
+        expect(namespaceInfo.hasAlias()).to.be.equal(false);
+    });
+
     // region functions
     function createRootFromDTO(dto): NamespaceInfo {
         return new NamespaceInfo(

test/model/transaction/AddressAliasTransaction.spec.ts

@@ -51,8 +51,6 @@ describe('AddressAliasTransaction', () => {
 
         const signedTransaction = addressAliasTransaction.signWith(account);
 
-        console.log(signedTransaction.payload);
-
         expect(signedTransaction.payload.substring(
             240,
             signedTransaction.payload.length,