@eluvio/elv-client-js 4.2.24 → 4.2.27

package/utilities/lib/data/network_specs.json

@@ -0,0 +1,13 @@
+{
+  "dev": {
+    "contentSpaceId": "ispc3ANoVSzNA3P6t7abLR69ho5YPPZU",
+    "networkId": 955210,
+    "networkName": "dev",
+    "fabricVersion": 3,
+    "fabricURIs": ["http://127.0.0.1:8008"],
+    "ethereumURIs": ["https://host-76-74-28-234.contentfabric.io/eth/"],
+    "fileServiceURIs": ["http://127.0.0.1:8008"],
+    "authServiceURIs": [],
+    "searchURIs": []
+  }
+}

package/utilities/lib/models/CredentialSet.js

@@ -16,17 +16,36 @@ const StorageEndpointModel = SealedModel({
 });
 
 const CloudCredentialsModel = SealedModel({
-  access_key_id: NonBlankString,
-  secret_access_key: NonBlankString
-});
+  access_key_id: [NonBlankString],
+  secret_access_key: [NonBlankString],
+  signed_url: [NonBlankString]
+}).assert(
+  function hasOneAuthenticationMethod(credentials) {
+    const hasAccessKey = Boolean(credentials.access_key_id);
+    const hasSecret = Boolean(credentials.secret_access_key);
+    const hasSignedUrl = Boolean(credentials.signed_url);
+
+    return hasSignedUrl
+      ? !hasAccessKey && !hasSecret
+      : hasAccessKey && hasSecret;
+  },
+  "cloud_credentials must contain either signed_url or both access_key_id and secret_access_key"
+);
 
 const RemoteAccessModel = ObjectModel({
   protocol: "s3",
   platform: "aws",
-  path: NonBlankString,
-  storage_endpoint: StorageEndpointModel,
+  path: [NonBlankString],
+  storage_endpoint: [StorageEndpointModel],
   cloud_credentials: CloudCredentialsModel
-});
+}).assert(
+  function hasLocationForAccessKeyCredentials(remoteAccess) {
+    if(remoteAccess.cloud_credentials.signed_url) return true;
+
+    return Boolean(remoteAccess.path && remoteAccess.storage_endpoint);
+  },
+  "path and storage_endpoint are required when using access key credentials"
+);
 
 const CredentialModel = ObjectModel({
   path_matchers: TypedArrayNonEmpty(NonBlankString),
@@ -43,4 +62,4 @@ module.exports = {
   CheckedCredentialSet,
   CredentialModel,
   CredentialSetModel,
-};
+};

package/utilities/tests/unit/lib/concerns/Client.test.js

@@ -0,0 +1,96 @@
+const {expect} = require("chai");
+
+const {ElvClient} = require("../../../../../src/ElvClient");
+const Client = require("../../../../lib/concerns/Client");
+
+const logger = {
+  error: () => {},
+  log: () => {}
+};
+
+const context = ({args={}, env={}} = {}) => ({
+  args: {
+    ethContractTimeout: 10,
+    ...args
+  },
+  concerns: {Logger: logger},
+  env: {
+    PRIVATE_KEY: "private-key",
+    ...env
+  }
+});
+
+const fakeClient = () => {
+  const nodeSelections = [];
+
+  return {
+    GenerateWallet: () => ({AddAccount: () => ({})}),
+    SetNodes: nodes => nodeSelections.push(nodes),
+    SetSigner: async () => {},
+    ToggleLogging: () => {},
+    nodeSelections
+  };
+};
+
+describe("Client concern", () => {
+  let originalFromConfigurationUrl;
+  let originalFromNetworkName;
+
+  beforeEach(() => {
+    originalFromConfigurationUrl = ElvClient.FromConfigurationUrl;
+    originalFromNetworkName = ElvClient.FromNetworkName;
+  });
+
+  afterEach(() => {
+    ElvClient.FromConfigurationUrl = originalFromConfigurationUrl;
+    ElvClient.FromNetworkName = originalFromNetworkName;
+  });
+
+  it("uses the main network by default", async () => {
+    let initArgs;
+    ElvClient.FromNetworkName = async args => {
+      initArgs = args;
+      return fakeClient();
+    };
+
+    await Client.New(context()).get();
+
+    expect(initArgs.networkName).to.equal("main");
+  });
+
+  it("uses a supplied config URL instead of the default network", async () => {
+    let initArgs;
+    ElvClient.FromConfigurationUrl = async args => {
+      initArgs = args;
+      return fakeClient();
+    };
+
+    await Client.New(context({args: {configUrl: "https://example.com/config"}})).get();
+
+    expect(initArgs.configUrl).to.equal("https://example.com/config");
+  });
+
+  it("uses an explicitly selected built-in network", async () => {
+    let initArgs;
+    ElvClient.FromNetworkName = async args => {
+      initArgs = args;
+      return fakeClient();
+    };
+
+    await Client.New(context({args: {network: "demo"}})).get();
+
+    expect(initArgs.networkName).to.equal("demo");
+  });
+
+  it("pins fabric and file-service requests to the supplied node", async () => {
+    const client = fakeClient();
+    ElvClient.FromNetworkName = async () => client;
+
+    await Client.New(context({args: {node: "fabric.example.com"}})).get();
+
+    expect(client.nodeSelections).to.deep.equal([{
+      fabricURIs: ["https://fabric.example.com"],
+      fileServiceURIs: ["https://fabric.example.com"]
+    }]);
+  });
+});