digicert 0.1.0 → 0.1.1

data/spec/digicert/container_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+RSpec.describe Digicert::Container do
+  describe ".all" do
+    it "retrieves the list of containers" do
+      stub_digicert_container_list_api
+      containers = Digicert::Container.all
+
+      expect(containers.first.id).not_to be_nil
+      expect(containers.first.name).to eq("Ribose Inc.")
+    end
+  end
+
+  describe ".create" do
+    it "creates a new sub container" do
+      stub_digicert_container_create_api(container_attributes)
+      container = Digicert::Container.create(container_attributes)
+
+      expect(container.id).not_to be_nil
+    end
+  end
+
+  describe ".fetch" do
+    it "retrieves the details for a container" do
+      container_id = 123_456_789
+
+      stub_digicert_container_fetch_api(container_id)
+      container = Digicert::Container.fetch(container_id)
+
+      expect(container.name).not_to be_nil
+      expect(container.parent_id).not_to be_nil
+      expect(container.allowed_domain_names.first).to eq("abc.xyz")
+    end
+  end
+
+  def container_attributes
+    {
+      container_id: 123_456_789,
+      name: "History Department",
+      template_id: 5,
+      description: "History, Civ, Ancient Languages",
+    }
+  end
+end

data/spec/digicert/container_template_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+RSpec.describe Digicert::ContainerTemplate do
+  describe ".all" do
+    it "retrieves the list of all container tempaltes" do
+      container_id = 123_456_789
+
+      stub_digicert_container_template_list_api(container_id)
+      container_templates = Digicert::ContainerTemplate.all(container_id)
+
+      expect(container_templates.count).to eq(2)
+      expect(container_templates.first.id).not_to be_nil
+      expect(container_templates.first.name).not_to be_nil
+    end
+  end
+
+  describe ".fetch" do
+    it "retrieves the specific container tempalte" do
+      template_id = 987_654_321
+      container_id = 123_456_789
+      stub_digicert_container_template_fetch_api(template_id, container_id)
+
+      container_template = Digicert::ContainerTemplate.fetch(
+        container_id: container_id, template_id: template_id,
+      )
+
+      expect(container_template.id).not_to be_nil
+      expect(container_template.name).not_to be_nil
+      expect(container_template.access_roles.first.name).to eq("Administrator")
+    end
+  end
+end

data/spec/digicert/csr_generator_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+RSpec.describe Digicert::CSRGenerator do
+  describe ".generate" do
+    it "returns the generated csr content" do
+      csr = Digicert::CSRGenerator.generate(
+        rsa_key: rsa_key_content,
+        organization: ribose_inc,
+        common_name: "ribosetest.com",
+      )
+
+      expect(csr.start_with?("-----BEGIN CERTIFICATE REQUEST")).to be_truthy
+      expect(csr.end_with?("--END CERTIFICATE REQUEST-----\n")).to be_truthy
+    end
+  end
+
+  def rsa_key_content
+    rsa_key_path = "../../fixtures/rsa4096.key"
+    File.read(File.expand_path(rsa_key_path, __FILE__))
+  end
+
+  def ribose_inc
+    double(
+      "Digicert::Organization",
+      name: "Ribose Inc.",
+      city: "Wilmington",
+      state: "Delaware",
+      country: "us",
+    )
+  end
+end

data/spec/digicert/domain_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+RSpec.describe Digicert::Domain do
+  describe ".create" do
+    it "creates a new domain for an organization" do
+      stub_digicert_domain_create_api(domain_attributes)
+      domain = Digicert::Domain.create(domain_attributes)
+
+      expect(domain.id).not_to be_nil
+    end
+  end
+
+  describe ".all" do
+    context "without any filters" do
+      it "retrieves the list of domains" do
+        stub_digicert_domain_list_api
+        domains = Digicert::Domain.all
+
+        expect(domains.count).to eq(2)
+        expect(domains.first.id).not_to be_nil
+        expect(domains.first.name).not_to be_nil
+      end
+    end
+
+    context "with custom filters" do
+      it "retrieves the filtered list" do
+        filter_params = { container_id: 123 }
+        stub_digicert_domain_list_api(filter_params)
+        domains = Digicert::Domain.all(filter_params)
+
+        expect(domains.count).to eq(2)
+        expect(domains.first.id).not_to be_nil
+        expect(domains.first.name).not_to be_nil
+      end
+    end
+  end
+
+  describe ".fetch" do
+    it "retrieves the specific domain" do
+      domain_id = 123_456_789
+      filters = { include_dcv: true, include_validation: true}
+
+      stub_digicert_domain_fetch_api(domain_id, filters)
+      domain = Digicert::Domain.fetch(domain_id, filters)
+
+      expect(domain.id).not_to be_nil
+      expect(domain.dcv.name_scope).not_to be_nil
+      expect(domain.validations.first.type).to eq("ev")
+    end
+  end
+
+  describe "#activate" do
+    it "activates a specific domain" do
+      domain_id = 123_456_789
+      domain = Digicert::Domain.find(domain_id)
+
+      stub_digicert_domain_activate_api(domain_id)
+      domain_activation = domain.activate
+
+      expect(domain_activation.code).to eq("204")
+    end
+  end
+
+  describe "#deactivate" do
+    it "deactivates a specific domain" do
+      domain_id = 123_456_789
+      domain = Digicert::Domain.find(domain_id)
+
+      stub_digicert_domain_deactivate_api(domain_id)
+      domain_deactivation = domain.deactivate
+
+      expect(domain_deactivation.code).to eq("204")
+    end
+  end
+
+  def domain_attributes
+    {
+      name: "digicert.com",
+      organization: { id: 117483 },
+      validations: [
+        {
+          type: "ev",
+          user: { id: 12 }
+        },
+      ],
+      dcv: { method: "email" },
+    }
+  end
+end

data/spec/digicert/duplicate_certificate_finder_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+RSpec.describe Digicert::DuplicateCertificateFinder do
+  describe ".find" do
+    it "finds the duplicate certificate" do
+      request_id = 123_456_789
+
+      stub_digicert_certificate_request_fetch_api(request_id)
+      stub_digicert_order_duplications_api(order_id)
+
+      certificate = Digicert::DuplicateCertificateFinder.find_by(
+        request_id: request_id,
+      )
+
+      expect(certificate.id).not_to be_nil
+    end
+  end
+
+  def order_id
+    # Fetching an existing request returns the fixtures file we
+    # wrote as certificate_request.json, and that order_id is
+    # being used to fetched the duplications, so for this use
+    # case let's keep it simple and hardcode the value for now
+    #
+    @order_id ||= 542757
+  end
+end

data/spec/digicert/duplicate_certificate_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+RSpec.describe Digicert::DuplicateCertificate do
+  describe ".all" do
+    it "list all duplicate certificates" do
+      order_id = 123_456_789
+
+      stub_digicert_order_duplications_api(order_id)
+      certificates = Digicert::DuplicateCertificate.all(order_id: order_id)
+
+      expect(certificates.first.id).not_to be_nil
+      expect(certificates.first.status).to eq("approved")
+    end
+  end
+end

data/spec/digicert/email_validation_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+RSpec.describe Digicert::EmailValidation do
+  describe ".all" do
+    it "retrieves the list of email with validation status" do
+      order_id = 123_456_789
+
+      stub_digicert_email_validations_api(order_id)
+      email_validations = Digicert::EmailValidation.all(order_id: order_id)
+
+      expect(email_validations.first.status).to eq("validated")
+      expect(email_validations.first.email).to eq("email@example.com")
+    end
+  end
+
+  describe ".valid?" do
+    it "validates the email through digicert" do
+      validation_attributes = { token: "token", email: "email@example.com" }
+      stub_digicert_email_validations_validate_api(validation_attributes)
+
+      expect(
+        Digicert::EmailValidation.valid?(validation_attributes),
+      ).to eq(true)
+    end
+  end
+end

data/spec/digicert/expiring_order_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+RSpec.describe Digicert::ExpiringOrder do
+  describe ".all" do
+    it "retrieves all the expiring orders" do
+      container_id = 123_456_789
+
+      stub_digicert_order_expiring_api(container_id)
+      expiring_orders = Digicert::ExpiringOrder.all(container_id: container_id)
+
+      expect(expiring_orders.count).to eq(4)
+      expect(expiring_orders.first.order_count).to eq(10)
+      expect(expiring_orders.first.days_expiring).to eq(90)
+    end
+  end
+end

data/spec/digicert/findable_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+require "digicert/base"
+
+RSpec.describe "Digicert::TestFindable" do
+  describe ".find_by_object" do
+    it "initialize an instnace using the object" do
+      findable_object = double("order", id: 123_456_789)
+      new_object = Digicert::TestFindable.find_by_object(findable_object)
+
+      expect(new_object.class).to eq(Digicert::TestFindable)
+    end
+  end
+
+  module Digicert
+    class TestFindable < Digicert::Base
+      extend Digicert::Findable
+    end
+  end
+end

data/spec/digicert/order_cancellation_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+RSpec.describe Digicert::OrderCancellation do
+  describe ".create" do
+    it "cancels an existing order" do
+      order_id = 123_456_789
+
+      stub_digicert_order_cancellation_api(order_id, cancellation_attributes)
+      order_cancellation = Digicert::OrderCancellation.create(
+        order_id: order_id, **cancellation_attributes,
+      )
+
+      expect(order_cancellation.code.to_i).to eq(204)
+    end
+  end
+
+  def cancellation_attributes
+    {
+      status: "CANCELED",
+      send_emails: true,
+      note: "This is a cancellation note",
+    }
+  end
+end

data/spec/digicert/order_duplicator_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+RSpec.describe Digicert::OrderDuplicator do
+  describe ".create" do
+    it "creates a duplicate of an existing order" do
+      stub_digicert_order_fetch_api(order_id)
+
+      stub_digicert_order_duplicate_api(order_id, order_attributes)
+      order = Digicert::OrderDuplicator.create(order_id: order_id)
+
+      expect(order.id).not_to be_nil
+      expect(order.requests.first.id).not_to be_nil
+    end
+  end
+
+  def order_id
+    123_456_789
+  end
+
+  def order_attributes
+    {
+      certificate: {
+        common_name: order.certificate.common_name,
+        dns_names: order.certificate.dns_names,
+        csr: order.certificate.csr,
+        signature_hash: order.certificate.signature_hash,
+        server_platform: { id: order.certificate.server_platform.id },
+      }
+    }
+  end
+
+  def order
+    @order ||= Digicert::Order.fetch(order_id)
+  end
+end

data/spec/digicert/order_reissuer_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+RSpec.describe Digicert::OrderReissuer do
+  describe ".create" do
+    it "reissue an existing order" do
+      stub_digicert_order_fetch_api(order_id)
+
+      stub_digicert_order_reissue_api(order_id, order_attributes)
+      order = Digicert::OrderReissuer.create(order_id: order_id)
+
+      expect(order.id).not_to be_nil
+      expect(order.requests.first.id).not_to be_nil
+    end
+  end
+
+  def order_id
+    123_456_789
+  end
+
+  def order
+    @order ||= Digicert::Order.fetch(order_id)
+  end
+
+  def order_attributes
+    {
+      certificate: {
+        common_name: order.certificate.common_name,
+        dns_names: order.certificate.dns_names,
+        csr: order.certificate.csr,
+        signature_hash: order.certificate.signature_hash,
+        server_platform: { id: order.certificate.server_platform.id },
+      }
+    }
+  end
+end

data/spec/digicert/order_spec.rb

@@ -0,0 +1,134 @@
+require "spec_helper"
+
+RSpec.describe Digicert::Order do
+  describe ".fetch" do
+    it "retrieves a specific certificate order" do
+      order_id = 123_456_789
+
+      stub_digicert_order_fetch_api(order_id)
+      order = Digicert::Order.fetch(order_id)
+
+      expect(order.id).not_to be_nil
+      expect(order.status).to eq("approved")
+      expect(order.certificate.common_name).to eq("digicert.com")
+    end
+  end
+
+  describe ".all" do
+    it "retrieves the list of all certificate orders" do
+      stub_digicert_order_list_api
+      orders = Digicert::Order.all
+
+      expect(orders.first.id).not_to be_nil
+      expect(orders.first.status).to eq("issued")
+      expect(orders.first.certificate.common_name).to eq("digicert.com")
+    end
+  end
+
+  describe ".create" do
+    it "sends create message to certificate klass" do
+      name_id = "ssl_plus"
+      allow(Digicert::SSLCertificate::SSLPlus).to receive(:create)
+
+      Digicert::Order.create(name_id, order_attributes)
+
+      expect(
+        Digicert::SSLCertificate::SSLPlus,
+      ).to have_received(:create).with(order_attributes)
+    end
+  end
+
+  describe "#email_validations" do
+    it "sends all message to EmailValidation" do
+      order_id = 123_456_789
+      order = Digicert::Order.find(order_id)
+      allow(Digicert::EmailValidation).to receive(:all)
+
+      order.email_validations
+
+      expect(
+        Digicert::EmailValidation,
+      ).to have_received(:all).with(order_id: order_id)
+    end
+  end
+
+  describe "#reissue" do
+    it "sends Reissuer a create message" do
+      order_id = 123_456_789
+      order = Digicert::Order.find(order_id)
+      allow(Digicert::OrderReissuer).to receive(:create)
+
+      order.reissue
+
+      expect(
+        Digicert::OrderReissuer
+      ).to have_received(:create).with(order_id: order_id)
+    end
+  end
+
+  describe "#duplicate" do
+    it "sends the duplicator a create message" do
+      order_id = 123_456_789
+      order = Digicert::Order.find(order_id)
+      allow(Digicert::OrderDuplicator).to receive(:create)
+
+      order.duplicate
+
+      expect(
+        Digicert::OrderDuplicator
+      ).to have_received(:create).with(order_id: order_id)
+    end
+  end
+
+  describe "#duplicate_certificates" do
+    it "sends all message to order duplication" do
+      order_id = 123_456_789
+      order = Digicert::Order.find(order_id)
+      allow(Digicert::DuplicateCertificate).to receive(:all)
+
+      order.duplicate_certificates
+
+      expect(
+        Digicert::DuplicateCertificate
+      ).to have_received(:all).with(order_id: order_id)
+    end
+  end
+
+  describe "#cancel" do
+    it "sends the create methods to order cancellation" do
+      order_id = 123_456_789
+      note = "This is the cancellation note"
+
+      order = Digicert::Order.find(order_id)
+      allow(Digicert::OrderCancellation).to receive(:create)
+
+      order.cancel(note: note)
+
+      expect(
+        Digicert::OrderCancellation
+      ).to have_received(:create).with(order_id: order_id, note: note)
+    end
+  end
+
+  def order_attributes
+    {
+      certificate: {
+        organization_units: ["Developer Operations"],
+        server_platform: { id: 45 },
+        profile_option: "some_ssl_profile",
+
+        # Required for certificate
+        csr: "------ [CSR HERE] ------",
+        common_name: "digicert.com",
+        signature_hash: "sha256",
+      },
+      organization: { id: 117483 },
+      validity_years: 3,
+      custom_expiration_date: "2017-05-18",
+      comments: "Comments for the the approver",
+      disable_renewal_notifications: false,
+      renewal_of_order_id: 314152,
+      payment_method: "balance",
+    }
+  end
+end