digicert 0.1.0 → 0.1.1

data/spec/requests/order_ssl_wildcard_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+RSpec.describe "Order SSLWildcard" do
+  describe "ordering ssl wildcard certificate", api_call: true do
+    it "creates a new order for ssl wildcard certificate" do
+      product_name_id = "ssl_wildcard"
+
+      # Reqeust a new certificate using the order creation
+      # interface by providing t`name_id` and required attributes
+      #
+      order_request = Digicert::Order.create(
+        product_name_id, order_attributes,
+      )
+
+      # Retrieve order details using the order_request id as
+      # it should contains the `certifcate`, so we then can
+      # download the generated certificate
+      #
+      order = Digicert::Order.fetch(order_request.id)
+
+      expect(order.product.name).to eq("WildCard Plus")
+      expect(order.certificate.common_name).to eq(common_name)
+      expect(order.organization.display_name).to eq(ribose_inc.display_name)
+    end
+  end
+
+  def common_name
+    "*.ribosetest.com"
+  end
+
+  def order_attributes
+    {
+      validity_years: 1,
+      certificate: certificate_attributes,
+      organization: { id: ribose_inc.id },
+    }
+  end
+
+  def ribose_inc
+    @ribose_inc ||= Digicert::Organization.all.first
+  end
+
+  def certificate_attributes
+    {
+      common_name: common_name,
+      signature_hash: "sha256",
+      csr: csr_content_for_ribosetest,
+      server_platform: { id: 2 },
+    }
+  end
+
+  def csr_content_for_ribosetest
+    @csr_content ||= Digicert::CSRGenerator.generate(
+      common_name: common_name, organization: ribose_inc,
+    )
+  end
+end

data/spec/requests/organization_management_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+RSpec.describe "Organization Management" do
+  describe "fetching an organization", api_call: true do
+    it "fetches the organization details" do
+      organizations = Digicert::Organization.all
+      organization = Digicert::Organization.fetch(organizations.first.id)
+
+      expect(organization.name).to eq("Ribose Inc.")
+      expect(organization.id).to eq(organization_id)
+      expect(organization.container.id).to eq(container_id)
+    end
+  end
+
+  def container_id
+    @container_id ||= ENV["DIGICERT_CONTAINER_ID"].to_i
+  end
+
+  def organization_id
+    @organization_id ||= ENV["DIGICERT_ORGANIZATION_ID"].to_i
+  end
+end

data/spec/requests/product_management_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+RSpec.describe "Product Management" do
+  describe "fetching a specific product", api_call: true do
+    it "fetches the details for a specific product" do
+      product = Digicert::Product.fetch(product_name_id)
+
+      expect(product.name).to eq("SSL Plus")
+      expect(product.allowed_validity_years).to eq([1, 2, 3])
+      expect(product.signature_hash_types.default_hash_type_id).to eq("sha256")
+    end
+  end
+
+  def product_name_id
+    @name_id ||= products.first.name_id
+  end
+
+  def products
+    # We are intentionally making this api call to verify
+    # the `.all` interface is working as it should have.
+    #
+    @products ||= Digicert::Product.all
+  end
+end

data/spec/requests/request_management_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+RSpec.describe "Request Management" do
+  describe "fetching a specific request", api_call: true do
+    it "fetches the details for a specific request" do
+      request = Digicert::CertificateRequest.fetch(request_id)
+
+      expect(request.status).to eq("approved")
+      expect(request.order.organization.name).to eq("Ribose Inc.")
+      expect(request.order.certificate.common_name).to eq("ribosetest.com")
+    end
+  end
+
+  def request_id
+    @request_id ||= requests.first.id
+  end
+
+  def requests
+    # We are intentionally making this API call to ensure
+    # the `.all` interface is working as it should have.
+    #
+    @requests ||= Digicert::CertificateRequest.all
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require "dotenv/load"
+require "webmock/rspec"
+require "bundler/setup"
+require "digicert"
+
+Dir["./spec/support/**/*.rb"].sort.each { |file| require file }
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before :all do
+    Digicert.configure do |digicert_config|
+      digicert_config.debug_mode = false
+      digicert_config.api_key = ENV["SECRET_DEV_API_KEY"] || "SECRET_KEY"
+    end
+  end
+
+  # Skip the actual API calls by default
+  config.filter_run_excluding api_call: true
+
+  # Allow the net_connection when we actually want to
+  # perform an actual API reques
+  #
+  config.before :each, api_call: true do
+    Digicert.configuration.debug_mode = true
+    WebMock.allow_net_connect!
+  end
+
+  config.include Digicert::FakeDigicertApi
+end

data/spec/support/fake_digicert_api.rb

@@ -0,0 +1,324 @@
+module Digicert
+  module FakeDigicertApi
+    def stub_digicert_product_list_api
+      stub_api_response(
+        :get, "product", filename: "products", status: 200,
+      )
+    end
+
+    def stub_digicert_product_fetch_api(name_id)
+      stub_api_response(
+        :get, ["product", name_id].join("/"), filename: "product", status: 200,
+      )
+    end
+
+    def stub_digicert_certificate_request_list_api
+      stub_api_response(
+        :get, "request", filename: "certificate_requests", status: 200,
+      )
+    end
+
+    def stub_digicert_certificate_request_fetch_api(request_id)
+      stub_api_response(
+        :get,
+        ["request", request_id].join("/"),
+        filename: "certificate_request",
+        status: 200,
+      )
+    end
+
+    def stub_digicert_certificate_request_update_api(request_id, attributes)
+      stub_api_response(
+        :put,
+        ["request", request_id, "status"].join("/"),
+        data: attributes,
+        filename: "empty",
+        status: 204,
+      )
+    end
+
+    def stub_digicert_order_create_api(certificate_type, attributes)
+      stub_api_response(
+        :post,
+        ["order/certificate", certificate_type].join("/"),
+        data: attributes,
+        filename: "order_created",
+        status: 201,
+      )
+    end
+
+    def stub_digicert_order_fetch_api(order_id)
+      stub_api_response(
+        :get, ["order/certificate", order_id].join("/"), filename: "order",
+      )
+    end
+
+    def stub_digicert_order_list_api
+      stub_api_response(
+        :get, "order/certificate", filename: "orders", status: 200,
+      )
+    end
+
+    def stub_digicert_certificate_order_fetch_api(order_id)
+      stub_api_response(
+        :get, ["order/certificate", order_id].join("/"), filename: "order",
+      )
+    end
+
+    def stub_digicert_organization_list_api
+      stub_api_response(
+        :get, "organization", filename: "organizations", status: 200,
+      )
+    end
+
+    def stub_digicert_organization_create_api(organization_attributes)
+      stub_api_response(
+        :post,
+        "organization",
+        data: organization_attributes,
+        filename: "organization_created",
+        status: 201,
+      )
+    end
+
+    def stub_digicert_organization_fetch_api(id)
+      stub_api_response(
+        :get, ["organization", id].join("/"), filename: "organization",
+      )
+    end
+
+    def stub_digicert_container_template_list_api(container_id)
+      stub_api_response(
+        :get,
+        ["container", container_id, "template"].join("/"),
+        filename: "container_templates",
+        status: 200,
+      )
+    end
+
+    def stub_digicert_container_template_fetch_api(template_id, container_id)
+      stub_api_response(
+        :get,
+        ["container", container_id, "template", template_id].join("/"),
+        filename: "container_template",
+        status: 200,
+      )
+    end
+
+    def stub_digicert_container_create_api(container_id:, **attributes)
+      stub_api_response(
+        :post,
+        ["container", container_id, "children"].join("/"),
+        data: attributes,
+        filename: "container_created",
+        status: 201,
+      )
+    end
+
+    def stub_digicert_container_list_api
+      stub_api_response(
+        :get, "container", filename: "containers", status: 200,
+      )
+    end
+
+    def stub_digicert_container_fetch_api(container_id)
+      stub_api_response(
+        :get, ["container", container_id].join("/"), filename: "container",
+      )
+    end
+
+    def stub_digicert_domain_create_api(attributes)
+      stub_api_response(
+        :post,
+        "domain",
+        data: attributes,
+        filename: "domain_created",
+        status: 201,
+      )
+    end
+
+    def stub_digicert_domain_list_api(filters = {})
+      stub_api_response(
+        :get, path_with_query("domain", filters), filename: "domains",
+      )
+    end
+
+    def stub_digicert_domain_fetch_api(domain_id, filters)
+      stub_api_response(
+        :get,
+        path_with_query(["domain", domain_id].join("/"), filters),
+        filename: "domain",
+        status: 200,
+      )
+    end
+
+    def stub_digicert_domain_activate_api(domain_id)
+      stub_api_response(
+        :put,
+        ["domain", domain_id, "activate"].join("/"),
+        filename: "empty",
+        status: 204,
+      )
+    end
+
+    def stub_digicert_domain_deactivate_api(domain_id)
+      stub_api_response(
+        :put,
+        ["domain", domain_id, "deactivate"].join("/"),
+        filename: "empty",
+        status: 204,
+      )
+    end
+
+    def stub_digicert_email_validations_api(order_id)
+      stub_api_response(
+        :get,
+        ["order", "certificate", order_id, "email-validation"].join("/"),
+        filename: "email_validations",
+        status: 200,
+      )
+    end
+
+    def stub_digicert_email_validations_validate_api(token:, email:)
+      stub_api_response(
+        :put,
+        path_with_query("email-validation/#{token}", email: email),
+        filename: "empty",
+        status: 204,
+      )
+    end
+
+    def stub_digicert_order_reissue_api(order_id, attributes)
+      stub_api_response(
+        :post,
+        ["order", "certificate", order_id, "reissue"].join("/"),
+        data: attributes,
+        filename: "order_reissued",
+        status: 201,
+      )
+    end
+
+    def stub_digicert_order_duplicate_api(order_id, attributes)
+      stub_api_response(
+        :post,
+        ["order", "certificate", order_id, "duplicate"].join("/"),
+        data: attributes,
+        filename: "order_duplicated",
+        status: 201,
+      )
+    end
+
+    def stub_digicert_order_duplications_api(order_id)
+      stub_api_response(
+        :get,
+        ["order", "certificate", order_id, "duplicate"].join("/"),
+        filename: "order_duplications",
+        status: 200,
+      )
+    end
+
+    def stub_digicert_order_cancellation_api(order_id, attributes)
+      stub_api_response(
+        :put,
+        ["order", "certificate", order_id, "status"].join("/"),
+        data: attributes,
+        filename: "empty",
+        status: 204,
+      )
+    end
+
+    def stub_digicert_order_expiring_api(container_id)
+      stub_api_response(
+        :get,
+        ["report", "order", container_id, "expiring"].join("/"),
+        filename: "expiring_orders",
+        status: 200,
+      )
+    end
+
+    def stub_digicert_certificate_revoke_api(id, attributes)
+      stub_api_response(
+        :put,
+        ["certificate", id, "revoke"].join("/"),
+        data: attributes,
+        filename: "certificate_revoked",
+        status: 201,
+      )
+    end
+
+    def stub_digicert_certificate_download_by_format(id, format, ext = "zip")
+      stub_api_response_with_io(
+        :get,
+        ["certificate", id, "download", "format", format].join("/"),
+        filename: ["certificate", ext].join("."),
+        status: 200,
+      )
+    end
+
+    def stub_digicert_certificate_download_by_platform(id, platform = nil)
+      stub_api_response_with_io(
+        :get,
+        ["certificate", id, "download", "platform", platform].compact.join("/"),
+        filename: "certificate.zip",
+        status: 200,
+      )
+    end
+
+    def stub_api_response(method, end_point, filename:, status: 200, data: nil)
+      stub_request(method, digicert_api_end_point(end_point)).
+        with(digicert_api_request_headers(data: data)).
+        to_return(response_with(filename: filename, status: status))
+    end
+
+    def stub_api_response_with_io(method, end_point, filename:, status: 200)
+      stub_request(method, digicert_api_end_point(end_point)).
+        with(digicert_api_request_headers(data: nil)).
+        to_return(response_with_file(file: filename, status: status))
+    end
+
+    private
+
+    def digicert_api_end_point(end_point)
+      ["https://www.digicert.com/services/v2", end_point].join("/")
+    end
+
+    def path_with_query(path, params)
+      query_params = params.map { |key, value| "#{key}=#{value}" }.join("&")
+      [path, query_params].join("?")
+    end
+
+    def digicert_api_request_headers(data: nil)
+      Hash.new.tap do |request_headers|
+        request_headers[:headers] = api_key_header
+        unless data.nil?
+          request_headers[:body] = data.to_json
+        end
+      end
+    end
+
+    def response_with(filename:, status:)
+      { body: digicert_fixture(filename), status: status }
+    end
+
+    def response_with_file(file:, status:)
+      {
+        status: status,
+        body: File.new(File.expand_path("../../fixtures/#{file}", __FILE__)),
+      }
+    end
+
+    def api_key_header
+      {
+        "Content-Type" => "application/json",
+        "X-DC-DEVKEY" => Digicert.configuration.api_key
+      }
+    end
+
+    def digicert_fixture(filename)
+      file_name = [filename, "json"].join(".")
+      file_path = ["../../", "fixtures", file_name].join("/")
+
+      File.read(File.expand_path(file_path, __FILE__))
+    end
+  end
+end