cloudflare 4.0.1 → 4.2.0

data/spec/cloudflare/accounts_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe Cloudflare::Accounts, order: :defined, timeout: 30 do
+	include_context Cloudflare::Account
+
+	before do
+		account.id # Force a fetch if it hasn't happened yet
+	end
+
+	it 'can list existing accounts' do
+		accounts = connection.accounts.to_a
+		expect(accounts.any? {|a| a.id == account.id }).to be true
+	end
+
+	it 'can get a specific account' do
+		expect(connection.accounts.find_by_id(account.id).id).to eq account.id
+	end
+
+	it 'can generate a representation for the KV namespace endpoint' do
+		ns = connection.accounts.find_by_id(account.id).kv_namespaces
+		expect(ns).to be_kind_of(Cloudflare::KV::Namespaces)
+		expect(ns.resource.reference.path).to end_with("/#{account.id}/storage/kv/namespaces")
+	end
+end

data/spec/cloudflare/custom_hostname/ssl_attribute/settings_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe Cloudflare::CustomHostname::SSLAttribute::Settings do
+
+	subject { described_class.new({}) }
+
+	it 'has an accessor for ciphers' do
+		ciphers = double
+		expect(subject.ciphers).to be_nil
+		subject.ciphers = ciphers
+		expect(subject.ciphers).to be ciphers
+	end
+
+	it 'has a boolean accessor for http2' do
+		expect(subject.http2).to be_nil
+		expect(subject.http2?).to be false
+		subject.http2 = true
+		expect(subject.http2).to eq 'on'
+		expect(subject.http2?).to be true
+		subject.http2 = false
+		expect(subject.http2).to eq 'off'
+		expect(subject.http2?).to be false
+		subject.http2 = 'on'
+		expect(subject.http2).to eq 'on'
+		expect(subject.http2?).to be true
+		subject.http2 = 'off'
+		expect(subject.http2).to eq 'off'
+		expect(subject.http2?).to be false
+	end
+
+	it 'has an accessor for min_tls_version' do
+		tls_version = double
+		expect(subject.min_tls_version).to be_nil
+		subject.min_tls_version = tls_version
+		expect(subject.min_tls_version).to be tls_version
+	end
+
+	it 'has a boolean accessor for tls_1_3' do
+		expect(subject.tls_1_3).to be_nil
+		expect(subject.tls_1_3?).to be false
+		subject.tls_1_3 = true
+		expect(subject.tls_1_3).to eq 'on'
+		expect(subject.tls_1_3?).to be true
+		subject.tls_1_3 = false
+		expect(subject.tls_1_3).to eq 'off'
+		expect(subject.tls_1_3?).to be false
+		subject.tls_1_3 = 'on'
+		expect(subject.tls_1_3).to eq 'on'
+		expect(subject.tls_1_3?).to be true
+		subject.tls_1_3 = 'off'
+		expect(subject.tls_1_3).to eq 'off'
+		expect(subject.tls_1_3?).to be false
+	end
+
+
+end

data/spec/cloudflare/custom_hostname/ssl_attribute_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe Cloudflare::CustomHostname::SSLAttribute do
+
+	accessors = [:cname, :cname_target, :http_body, :http_url, :method, :status, :type, :validation_errors]
+
+	let(:original_hash) { {} }
+
+	subject { described_class.new(original_hash) }
+
+	accessors.each do |key|
+
+		it "has an accessor for the #{key} value" do
+			test_value = double
+			expect(subject.send(key)).to be_nil
+			original_hash[key] = test_value
+			expect(subject.send(key)).to be test_value
+		end
+
+	end
+
+	it '#active? returns true when the status is "active" and false otherwise' do
+		expect(subject.active?).to be false
+		original_hash[:status] = 'initializing'
+		expect(subject.active?).to be false
+		original_hash[:status] = 'pending_validation'
+		expect(subject.active?).to be false
+		original_hash[:status] = 'pending_deployment'
+		expect(subject.active?).to be false
+		original_hash[:status] = 'active'
+		expect(subject.active?).to be true
+	end
+
+	it '#pending_validation? returns true when the status is "pending_validation" and false otherwise' do
+		expect(subject.pending_validation?).to be false
+		original_hash[:status] = 'initializing'
+		expect(subject.pending_validation?).to be false
+		original_hash[:status] = 'active'
+		expect(subject.pending_validation?).to be false
+		original_hash[:status] = 'pending_deployment'
+		expect(subject.pending_validation?).to be false
+		original_hash[:status] = 'pending_validation'
+		expect(subject.pending_validation?).to be true
+	end
+
+	describe '#settings' do
+
+		it 'should return a Settings object' do
+			expect(subject.settings).to be_kind_of Cloudflare::CustomHostname::SSLAttribute::Settings
+		end
+
+		it 'initailizes the settings object with the value from the settings key' do
+			settings = { min_tls_version: double }
+			original_hash[:settings] = settings
+			expect(subject.settings.min_tls_version).to be settings[:min_tls_version]
+		end
+
+		it 'initializes the settings object with a new hash if the settings key does not exist' do
+			expected_value = double
+			expect(original_hash[:settings]).to be_nil
+			expect(subject.settings.min_tls_version).to be_nil
+			expect(original_hash[:settings]).not_to be_nil
+			original_hash[:settings][:min_tls_version] = expected_value
+			expect(subject.settings.min_tls_version).to be expected_value
+		end
+
+		it 'updates the stored hash with values set on the settings object' do
+			expected_value = double
+			expect(subject.settings.min_tls_version).to be_nil
+			subject.settings.min_tls_version = expected_value
+			expect(original_hash[:settings][:min_tls_version]).to be expected_value
+		end
+	end
+
+end

data/spec/cloudflare/custom_hostnames_spec.rb

@@ -0,0 +1,213 @@
+
+RSpec.xdescribe Cloudflare::CustomHostnames, order: :defined, timeout: 30 do
+	include_context Cloudflare::Zone
+
+	let(:domain) { "www#{ENV['TRAVIS_JOB_ID'] || rand(1..5)}.ourtest.com" }
+
+	let(:record) { @record = zone.custom_hostnames.create(domain) }
+
+	let(:custom_origin) do
+		id = rand(1...100)
+		id += (job_id * 100) if job_id.positive?
+		subdomain = "origin-#{id}"
+		@dns_record = zone.dns_records.create("A", subdomain, "1.2.3.4") # This needs to exist or the calls will fail
+		"#{subdomain}.#{zone.name}"
+	end
+
+	after do
+		if defined? @record
+			expect(@record.delete).to be_success
+		end
+
+		if defined? @dns_record
+			expect(@dns_record.delete).to be_success
+		end
+	end
+
+	it 'can create a custom hostname record' do
+		expect(record).to be_kind_of Cloudflare::CustomHostname
+		expect(record.custom_metadata).to be_nil
+		expect(record.hostname).to eq domain
+		expect(record.custom_origin).to be_nil
+		expect(record.ssl.method).to eq 'http'
+		expect(record.ssl.type).to eq 'dv'
+	end
+
+	it 'can create a custom hostname record with a custom origin' do
+		begin
+			@record = zone.custom_hostnames.create(domain, origin: custom_origin)
+
+			expect(@record).to be_kind_of Cloudflare::CustomHostname
+			expect(@record.custom_metadata).to be_nil
+			expect(@record.hostname).to eq domain
+			expect(@record.custom_origin).to eq custom_origin
+			expect(@record.ssl.method).to eq 'http'
+			expect(@record.ssl.type).to eq 'dv'
+		rescue Cloudflare::RequestError => e
+			if e.message.include?('custom origin server has not been granted')
+				skip(e.message) # This currently doesn't work but might start eventually: https://github.com/socketry/async-rspec/issues/7
+			else
+				raise
+			end
+		end
+	end
+
+	it 'can create a custom hostname record with different ssl options' do
+		@record = zone.custom_hostnames.create(domain, ssl: { method: 'cname' })
+
+		expect(@record).to be_kind_of Cloudflare::CustomHostname
+		expect(@record.custom_metadata).to be_nil
+		expect(@record.hostname).to eq domain
+		expect(@record.custom_origin).to be_nil
+		expect(@record.ssl.method).to eq 'cname'
+		expect(@record.ssl.type).to eq 'dv'
+	end
+
+	it 'can create a custom hostname record with additional metadata' do
+		metadata = { a: rand(1..10) }
+
+		begin
+			@record = zone.custom_hostnames.create(domain, metadata: metadata)
+
+			expect(@record).to be_kind_of Cloudflare::CustomHostname
+			expect(@record.custom_metadata).to eq metadata
+			expect(@record.hostname).to eq domain
+			expect(@record.custom_origin).to be_nil
+			expect(@record.ssl.method).to eq 'http'
+			expect(@record.ssl.type).to eq 'dv'
+		rescue Cloudflare::RequestError => e
+			if e.message.include?('No custom metadata access has been allocated for this zone')
+				skip(e.message) # This currently doesn't work but might start eventually: https://github.com/socketry/async-rspec/issues/7
+			else
+				raise
+			end
+		end
+	end
+
+	it 'can look up an existing custom hostname by the hostname or id' do
+		expect(zone.custom_hostnames.find_by_hostname(record.hostname).id).to eq record.id
+		expect(zone.custom_hostnames.find_by_id(record.id).id).to eq record.id
+	end
+
+	context 'with existing record' do
+
+		it 'returns the hostname when calling #to_s' do
+			expect(record.to_s).to eq domain
+		end
+
+		it 'can update metadata' do
+			metadata = { c: rand(1..10) }
+
+			expect(record.custom_metadata).to be_nil
+
+			begin
+				record.update_settings(metadata: metadata)
+
+				# Make sure the existing object is updated
+				expect(record.custom_metadata).to eq metadata
+
+				# Verify that the server has the changes
+				found_record = zone.custom_hostnames.find_by_id(record.id)
+
+				expect(found_record.custom_metadata).to eq metadata
+				expect(found_record.hostname).to eq domain
+				expect(found_record.custom_origin).to be_nil
+			rescue Cloudflare::RequestError => e
+				if e.message.include?('No custom metadata access has been allocated for this zone')
+					skip(e.message) # This currently doesn't work but might start eventually: https://github.com/socketry/async-rspec/issues/7
+				else
+					raise
+				end
+			end
+		end
+
+		it 'can update the custom origin' do
+			expect(record.custom_origin).to be_nil
+
+			begin
+				record.update_settings(origin: custom_origin)
+
+				# Make sure the existing object is updated
+				expect(record.custom_origin).to eq custom_origin
+
+				# Verify that the server has the changes
+				found_record = zone.custom_hostnames.find_by_id(record.id)
+
+				expect(found_record.custom_metadata).to be_nil
+				expect(found_record.hostname).to eq domain
+				expect(found_record.custom_origin).to eq custom_origin
+			rescue Cloudflare::RequestError => e
+				if e.message.include?('custom origin server has not been granted')
+					skip(e.message) # This currently doesn't work but might start eventually: https://github.com/socketry/async-rspec/issues/7
+				else
+					raise
+				end
+			end
+		end
+
+		it 'can update ssl information' do
+				expect(record.ssl.method).to eq 'http'
+
+				record.update_settings(ssl: { method: 'cname', type: 'dv' })
+
+				# Make sure the existing object is updated
+				expect(record.ssl.method).to eq 'cname'
+
+				# Verify that the server has the changes
+				found_record = zone.custom_hostnames.find_by_id(record.id)
+
+				expect(found_record.custom_metadata).to be_nil
+				expect(found_record.hostname).to eq domain
+				expect(found_record.custom_origin).to be_nil
+				expect(found_record.ssl.method).to eq 'cname'
+		end
+
+		context 'has an ssl section' do
+
+			it 'wraps it in an SSLAttributes object' do
+				expect(record.ssl).to be_kind_of Cloudflare::CustomHostname::SSLAttribute
+			end
+
+			it 'has some helpers for commonly used keys' do
+				# Make sure our values exist before we check to make sure that they are returned correctly
+				expect(record.value[:ssl].values_at(:method, :http_body, :http_url).compact).not_to be_empty
+				expect(record.ssl.method).to be record.value[:ssl][:method]
+				expect(record.ssl.http_body).to be record.value[:ssl][:http_body]
+				expect(record.ssl.http_url).to be record.value[:ssl][:http_url]
+			end
+
+		end
+
+		describe '#ssl_active?' do
+
+			it 'returns the result of calling ssl.active?' do
+				expected_value = double
+				expect(record.ssl).to receive(:active?).and_return(expected_value)
+				expect(record).not_to receive(:send_patch)
+				expect(record.ssl_active?).to be expected_value
+			end
+
+			it 'returns the result of calling ssl.active? without triggering an update if force_update is true and the ssl is not in the pending_validation state' do
+				expected_value = double
+				expect(record.ssl).to receive(:active?).and_return(expected_value)
+				expect(record.ssl.method).not_to be_nil
+				expect(record.ssl.type).not_to be_nil
+				expect(record.ssl.pending_validation?).to be false
+				expect(record).not_to receive(:send_patch).with(ssl: { method: record.ssl.method, type: record.ssl.type })
+				expect(record.ssl_active?(true)).to be expected_value
+			end
+
+			it 'returns the result of calling ssl.active? after triggering an update if force_update is true and the ssl is in the pending_validation state' do
+				expected_value = double
+				expect(record.ssl).to receive(:active?).and_return(expected_value)
+				expect(record.ssl.method).not_to be_nil
+				expect(record.ssl.type).not_to be_nil
+				record.value[:ssl][:status] = 'pending_validation'
+				expect(record).to receive(:send_patch).with(ssl: { method: record.ssl.method, type: record.ssl.type })
+				expect(record.ssl_active?(true)).to be expected_value
+			end
+
+		end
+
+	end
+end

data/spec/cloudflare/dns_spec.rb

@@ -6,21 +6,31 @@ RSpec.describe Cloudflare::DNS, order: :defined, timeout: 30 do
 	
 	let(:subdomain) {"www#{ENV['TRAVIS_JOB_ID']}"}
 	
-	let(:record) {@record = zone.dns_records.create("A", subdomain, "1.2.3.4")}
-	
 	after do
 		if defined? @record
 			expect(@record.delete).to be_success
 		end
 	end
 	
-	it "can create dns record" do
-		expect(record.type).to be == "A"
-		expect(record.name).to be_start_with subdomain
-		expect(record.content).to be == "1.2.3.4"
+	context "new record" do
+		it "can create dns record" do
+			@record = zone.dns_records.create("A", subdomain, "1.2.3.4")
+			expect(@record.type).to be == "A"
+			expect(@record.name).to be_start_with subdomain
+			expect(@record.content).to be == "1.2.3.4"
+		end
+		
+		it "can create dns record with proxied option" do
+			@record = zone.dns_records.create("A", subdomain, "1.2.3.4", proxied: true)
+			expect(@record.type).to be == "A"
+			expect(@record.name).to be_start_with subdomain
+			expect(@record.content).to be == "1.2.3.4"
+			expect(@record.proxied).to be_truthy
+		end
 	end
 	
 	context "with existing record" do
+		let(:record) {@record = zone.dns_records.create("A", subdomain, "1.2.3.4")}
 		it "can update dns content" do
 			record.update_content("4.3.2.1")
 			expect(record.content).to be == "4.3.2.1"
@@ -28,5 +38,13 @@ RSpec.describe Cloudflare::DNS, order: :defined, timeout: 30 do
 			fetched_record = zone.dns_records.find_by_name(record.name)
 			expect(fetched_record.content).to be == record.content
 		end
+		
+		it "can update dns content with proxied option" do
+			record.update_content("4.3.2.1", proxied: true)
+			expect(record.proxied).to be_truthy
+			
+			fetched_record = zone.dns_records.find_by_name(record.name)
+			expect(fetched_record.proxied).to be_truthy
+		end
 	end
 end

data/spec/cloudflare/kv/namespaces_spec.rb

@@ -0,0 +1,71 @@
+
+RSpec.describe Cloudflare::KV::Namespaces, kv_spec: true, order: :defined, timeout: 30 do
+	include_context Cloudflare::Account
+
+	let(:namespace) { @namespace = account.kv_namespaces.create(namespace_title) }
+	let(:namespace_title) { "Test NS ##{rand(1..100)}" }
+
+	after do
+		if defined? @namespace
+			expect(@namespace.delete).to be_success
+		end
+	end
+
+	it 'can create a namespace' do
+		expect(namespace).to be_kind_of Cloudflare::KV::Namespace
+		expect(namespace.id).not_to be_nil
+		expect(namespace.title).to eq namespace_title
+	end
+
+	it 'can find a namespace by title' do
+		namespace # Call this so that the namespace gets created
+		expect(account.kv_namespaces.find_by_title(namespace_title).id).to eq namespace.id
+	end
+
+	it 'can rename the namespace' do
+		new_title = "#{namespace_title}-#{rand(1..100)}"
+		namespace.rename(new_title)
+		expect(namespace.title).to eq new_title
+		expect(account.kv_namespaces.find_by_title(new_title).id).to eq namespace.id
+		expect(account.kv_namespaces.find_by_title(namespace_title)).to be_nil
+	end
+
+	it 'can store a key/value, read it back' do
+		key = "key-#{rand(1..100)}"
+		value = rand(100..999)
+		namespace.write_value(key, value)
+		expect(account.kv_namespaces.find_by_id(namespace.id).read_value(key)).to eq value.to_s
+	end
+
+	it 'can read a previously stored key' do
+		key = "key-#{rand(1..100)}"
+		value = rand(100..999)
+		expect(account.kv_namespaces.find_by_id(namespace.id).write_value(key, value)).to be true
+		expect(namespace.read_value(key)).to eq value.to_s
+	end
+
+	it 'can delete keys' do
+		key = "key-#{rand(1..100)}"
+		value = rand(100..999)
+		expect(namespace.write_value(key, value)).to be true
+		expect(namespace.read_value(key)).to eq value.to_s
+		expect(namespace.delete_value(key)).to be true
+		expect do
+			account.kv_namespaces.find_by_id(namespace.id).read_value(key)
+		end.to raise_error(Cloudflare::RequestError)
+	end
+
+	it 'can get the keys that exist in the namespace' do
+		counter = 0
+		keys = Array.new(rand(1..9)) { "key-#{counter += 1}" } # Keep this single digits so ordering works
+		keys.each_with_index do |key, i|
+			namespace.write_value(key, i)
+		end
+
+		saved_keys = account.kv_namespaces.find_by_id(namespace.id).keys.to_a
+		expect(saved_keys.length).to eq keys.length
+		saved_keys.each_with_index do |key, i|
+			expect(key.name).to eq keys[i]
+		end
+	end
+end