brightbox-cli 5.0.0.alpha → 5.0.0.rc1

data/spec/unit/brightbox/api/fog_attributes_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::Api, "#fog_attributes" do
+  subject(:model_attributes) { api_model.fog_attributes }
+
+  let(:api_model) { Brightbox::Api.new(fog_model) }
+  let(:fog_model) do
+    double(
+      "Fog::Compute::Brightbox::Api",
+      id: "res-12345",
+      attributes: attributes
+    )
+  end
+
+  context "when attributes are not set" do
+    let(:attributes) { nil }
+
+    it "returns an indifferent access hash" do
+      expect(model_attributes).to be_instance_of(IndifferentAccessHash)
+    end
+  end
+
+  context "when attributes are set with a mix of string and symbols" do
+    let(:attributes) do
+      {
+        id: "res-12345",
+        name: "test",
+        acme: acme_details
+      }
+    end
+    let(:acme_details) do
+      {
+        "domains" => [
+          {
+            "identifier" => "example.test",
+            "status" => "pending"
+          }
+        ]
+      }
+    end
+
+    it "transforms the keys with deep symbolize" do
+      expect(model_attributes).to eq(
+        id: "res-12345",
+        name: "test",
+        acme: {
+          domains: [
+            {
+              identifier: "example.test",
+              status: "pending"
+            }
+          ]
+        }
+      )
+    end
+
+    it "can not accessed by string keys" do
+      expect(model_attributes["acme"]["domains"].first["identifier"]).to eq("example.test")
+    end
+
+    it "can accessed by symbol keys" do
+      expect(model_attributes[:acme][:domains].first[:identifier]).to eq("example.test")
+    end
+  end
+end

data/spec/unit/brightbox/cloud_ip/attributes_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::CloudIP, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Model",
+      id: "cip-12345",
+      destination_id: nil,
+      attributes: model_attributes
+    )
+  end
+  let(:model_attributes) { { id: "cip-12345" } }
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/collaborating_account/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::CollaboratingAccount, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/database_server/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::DatabaseServer, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/database_snapshot/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::DatabaseSnapshot, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/database_type/attributes_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::DatabaseType, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Model",
+      id: "typ-12345",
+      attributes: model_attributes,
+      ram: 1024,
+      disk: 10_240,
+    )
+  end
+  let(:model_attributes) { { id: "typ-12345" } }
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/detailed_server/attributes_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::DetailedServer, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Model",
+      id: "srv-12345",
+      attributes: model_attributes,
+      cloud_ips: [],
+      created_at: Time.parse("2025-01-01T12:00:00Z"),
+      created_on: "2025-01-01",
+      hostname: "srv-12345.gb1.brightbox.com",
+      image_id: "img-12345",
+      interfaces: [],
+      locked?: false,
+      type: "typ-12345",
+      state: "active",
+      server_type: "typ-12345",
+      zone: { id: "zon-12345", handle: "gb1-a" }
+    )
+  end
+  let(:model_attributes) { { id: "srv-12345" } }
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/detailed_server_group/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::DetailedServerGroup, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/firewall_policy/attributes_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::FirewallPolicy, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Model",
+      id: "res-12345",
+      attributes: model_attributes,
+      description: "",
+      server_group_id: "grp-12345",
+      name: "my-policy"
+    )
+  end
+  let(:model_attributes) { { id: "fwp-12345" } }
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/firewall_rule/attributes_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::FirewallRule, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Model",
+      id: "fwr-12345",
+      attributes: model_attributes
+    )
+  end
+  let(:model_attributes) { { id: "fwr-12345" } }
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/image/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::Image, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/image/status_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::Image, "#status" do
+  subject(:image) { Brightbox::Image.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Compute::Brightbox::Image",
+      id: "img-12345",
+      attributes: {
+        "id": "img-12345",
+        "status": status,
+        "public": is_public
+      },
+      public: is_public
+    )
+  end
+  let(:is_public) { false }
+
+  context "when the image is pending" do
+    let(:status) { "pending" }
+
+    it "returns 'pending'" do
+      expect(image.status).to eq("pending")
+    end
+  end
+
+  context "when the image is available" do
+    let(:status) { "available" }
+
+    context "with public visibility" do
+      let(:is_public) { true }
+
+      it "returns 'public'" do
+        expect(image.status).to eq("public")
+      end
+    end
+
+    context "without public visibility" do
+      let(:is_public) { false }
+
+      it "returns 'private'" do
+        expect(image.status).to eq("private")
+      end
+    end
+  end
+
+  context "when the image is deprecated" do
+    let(:status) { "deprecated" }
+
+    context "with public visibility" do
+      let(:is_public) { true }
+
+      it "returns 'deprecated'" do
+        expect(image.status).to eq("deprecated")
+      end
+    end
+
+    context "without public visibility" do
+      let(:is_public) { false }
+
+      it "returns 'private'" do
+        expect(image.status).to eq("private")
+      end
+    end
+  end
+end

data/spec/unit/brightbox/load_balancer/acme_cert_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::LoadBalancer, "#acme_cert" do
+  subject(:acme_cert) { load_balancer.acme_cert }
+
+  let(:fog_model) do
+    double(
+      "Fog::Compute::Brightbox::LoadBalancer",
+      id: "lba-12345",
+      attributes: lba_attributes
+    )
+  end
+  let(:load_balancer) { Brightbox::LoadBalancer.new(fog_model) }
+
+  context "when ACME is not setup" do
+    let(:lba_attributes) { { acme: nil } }
+
+    it "returns an empty string" do
+      expect(acme_cert).not_to be_nil
+    end
+  end
+
+  context "when ACME is setup" do
+    context "without certificate" do
+      let(:lba_attributes) do
+        { acme: { certificate: nil }}
+      end
+
+      it "returns an object without keys" do
+        expect(acme_cert).not_to be_nil
+
+        expect(acme_cert).to have_attributes(
+          expires_at: "",
+          fingerprint: "",
+          issued_at: "",
+          subjects: ""
+        )
+      end
+    end
+
+    context "with certificate" do
+      let(:expected_formatting) { "example.com:verified,example.net:pending" }
+      let(:lba_attributes) do
+        {
+          acme: {
+            domains: [
+              { identifier: "domain.one.test", status: "verified" },
+              { identifier: "domain.two.test", status: "verified" }
+            ],
+            certificate: {
+              domains: [
+                "domain.one.test",
+                "domain.two.test"
+              ],
+              expires_at: "2025-12-31T23:59:59Z",
+              fingerprint: "TLS-fingerprint",
+              issued_at: "2025-01-01T00:00:00Z"
+            }
+          }
+        }
+      end
+
+      it "returns an object with the correct keys" do
+        expect(acme_cert).not_to be_nil
+
+        expect(acme_cert).to have_attributes(
+          expires_at: "2025-12-31T23:59:59Z",
+          fingerprint: "TLS-fingerprint",
+          issued_at: "2025-01-01T00:00:00Z",
+          subjects: "domain.one.test,domain.two.test"
+        )
+      end
+    end
+  end
+end

data/spec/unit/brightbox/load_balancer/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::LoadBalancer, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/load_balancer/formatted_acme_domains_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::LoadBalancer, "#formatted_acme_domains" do
+  subject(:load_balancer) { Brightbox::LoadBalancer.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Compute::Brightbox::LoadBalancer",
+      id: "lba-12345",
+      attributes: lba_attributes
+    )
+  end
+  let(:lba_attributes) do
+    # Encode/decode JSON to get final key/value forms
+    JSON.parse({
+      id: "lba-12345",
+      acme: acme_details
+    }.to_json)
+  end
+
+  context "when ACME is not setup" do
+    let(:acme_details) { nil }
+
+    it "returns an empty array" do
+      expect(load_balancer.formatted_acme_domains).to eq("")
+    end
+  end
+
+  context "when no domains are returned" do
+    let(:acme_details) do
+      { domains: [] }
+    end
+
+    it "returns an empty array" do
+      expect(load_balancer.formatted_acme_domains).to eq("")
+    end
+  end
+
+  context "when multiple domains are returned" do
+    let(:acme_details) do
+      {
+        domains: [
+          {
+            identifier: "example.com",
+            status: "verified"
+          },
+          {
+            identifier: "example.net",
+            status: "pending"
+          }
+        ]
+      }
+    end
+    let(:expected_formatting) do
+      "example.com:verified,example.net:pending"
+    end
+
+    it "returns a comma separated list of domains and statuses" do
+      expect(load_balancer.formatted_acme_domains).to eq(expected_formatting)
+    end
+  end
+
+  context "when error occurs" do
+    let(:lba_attributes) do
+      # Encode/decode JSON to get final key/value forms
+      JSON.parse({
+        id: "lba-12345",
+        acme: {
+          domains: nil
+        }
+      }.to_json)
+    end
+
+    it "returns an empty array" do
+      expect(load_balancer.formatted_acme_domains).to eq("")
+    end
+  end
+end

data/spec/unit/brightbox/server/attributes_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::Server, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Model",
+      id: "srv-12345",
+      attributes: model_attributes,
+      cloud_ips: [],
+      created_at: Time.parse("2025-01-01T12:00:00Z"),
+      created_on: "2025-01-01",
+      hostname: "srv-12345.gb1.brightbox.com",
+      image_id: "img-12345",
+      interfaces: [],
+      locked?: false,
+      type: "typ-12345",
+      state: "active",
+      server_type: "typ-12345",
+      zone: { id: "zon-12345", handle: "gb1-a" }
+    )
+  end
+  let(:model_attributes) { { id: "srv-12345" } }
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/server_group/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::ServerGroup, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/type/attributes_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::Type, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double(
+      "Fog::Model",
+      id: "typ-12345",
+      attributes: model_attributes,
+      ram: 1_024,
+      disk: 10_240
+    )
+  end
+  let(:model_attributes) { { id: "typ-12345" } }
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/user/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::User, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end

data/spec/unit/brightbox/user_collaboration/attributes_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe Brightbox::UserCollaboration, "#attributes" do
+  subject { described_class.new(fog_model) }
+
+  let(:fog_model) do
+    double("Fog::Model", id: "res-12345", attributes: { id: "res-12345"})
+  end
+
+  it "returns an IndifferentAccessHash" do
+    expect(subject.attributes).to be_a(IndifferentAccessHash)
+  end
+end