diversion 0.0.1

data/spec/diversion/client_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Diversion::Client do
+
+  it "delegates to a client" do
+    expect(Diversion.encode(HTML)).to eq(html_params_encoded)
+  end
+
+  it "configures" do
+    client = Diversion::Client.new
+    client.configure do |c|
+      c.host = "dummy.host"
+    end
+    expect(client.host).to eq("dummy.host")
+  end
+
+  it "allows for separate configs" do
+    m1 = Diversion::Client.new({:host => "test1"})
+    m2 = Diversion::Client.new({:host => "test2"})
+    expect(m1.host).to_not eq(m2.host)
+  end
+
+end

data/spec/diversion/configurable_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+class ConfigTestStub
+  include Diversion::Configurable
+end
+
+describe Diversion::Configurable do
+
+  let(:config) { config = ConfigTestStub.new; config.reset!; config }
+
+  def set_config(&block) config.configure do |c| c.instance_eval(&block) end; end
+  def host(value); set_config{|c|c.host = value}; end
+  def path(value); set_config{|c|c.path = value}; end
+  def port(value); set_config{|c|c.port = value}; end
+  def encode_uris(value); set_config{|c|c.encode_uris = value}; end
+  def sign_length(value); set_config{|c|c.sign_length = value}; end
+  def url_encoding(value); set_config{|c|c.url_encoding = value}; end
+  def url_decoding(value); set_config{|c|c.url_decoding = value}; end
+
+  describe "host" do
+    it "must be a string" do
+      expect{host(1)}.to raise_error
+    end
+    it "accepts string type" do
+      expect{host('test')}.to_not raise_error
+    end
+    it "cannot end with trailing slash" do
+      expect{host('test/')}.to raise_error
+    end
+    it "doesnt accept nil" do
+      expect{host(nil)}.to raise_error
+    end
+  end
+
+  describe "path" do
+    it "must be a string" do
+      expect{path(1)}.to raise_error
+    end
+    it "accepts string type" do
+      expect{path('test/')}.to_not raise_error
+    end
+    it "must end with trailing slash" do
+      expect{path('test')}.to raise_error
+    end
+    it "doesnt accept nil" do
+      expect{path(nil)}.to raise_error
+    end
+  end
+
+  describe "port" do
+    it "must be an integer" do
+      expect{port('test')}.to raise_error
+    end
+    it "accepts an integer" do
+      expect{port(1)}.to_not raise_error
+    end
+    it "does not accept 0" do
+      expect{port(0)}.to raise_error
+    end
+    it "does not accept <0" do
+      expect{port(-1)}.to raise_error
+    end
+    it "doesnt accept nil" do
+      expect{port(nil)}.to raise_error
+    end
+  end
+
+  describe "sign_length" do
+    it "must be an integer" do
+      expect{sign_length('test')}.to raise_error
+    end
+    it "accepts 0 (disaled)" do
+      expect{sign_length(0)}.to_not raise_error
+    end
+    it "accepts integer at lower range" do
+      expect{sign_length(1)}.to_not raise_error
+    end
+    it "accepts integer at higher range" do
+      expect{sign_length(Diversion::Signing::MAX_SIGN_LENGTH)}.to_not raise_error
+    end
+    it "does not accept <0" do
+      expect{sign_length(-1)}.to raise_error
+    end
+    it "doesnt accept nil" do
+      expect{sign_length(nil)}.to raise_error
+    end
+  end
+
+  describe "encode_uris" do
+    it "must be an array" do
+      expect{encode_uris('test')}.to raise_error
+    end
+    it "accepts uri" do
+      expect{encode_uris(['http'])}.to_not raise_error
+    end
+    it "doesnt accept nil" do
+      expect{encode_uris(nil)}.to raise_error
+    end
+    it "doesnt accept empty array" do
+      expect{encode_uris([])}.to raise_error
+    end
+  end
+
+  describe "url_encoding" do
+    it "must be a module" do
+      expect{url_encoding('test')}.to raise_error
+    end
+    it "accepts a valid module" do
+      expect{url_encoding(Diversion::Encode::Json)}.to_not raise_error
+    end
+    it "doesn't accept an invalid module" do
+      expect{url_encoding(Diversion::Decode::Json)}.to raise_error
+    end
+  end
+
+  describe "url_decoding" do
+    it "must be a module" do
+      expect{url_decoding('test')}.to raise_error
+    end
+    it "accepts a valid module" do
+      expect{url_decoding(Diversion::Decode::Json)}.to_not raise_error
+    end
+    it "doesn't accept an invalid module" do
+      expect{url_decoding(Diversion::Encode::Json)}.to raise_error
+    end
+  end
+
+end

data/spec/diversion/decode/json_decode_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe Diversion::Decode::Json do
+
+  include_context "json"
+
+  it "returns correct type for non-signed" do
+    expect(decode_json).to be_a Hash
+  end
+
+  it "returns correct type for signed" do
+    expect(decode_json_signed).to be_a Hash
+  end
+
+  it "raises when data format invalid" do
+    expect{client.decode("test-test-test")}.to raise_error(Diversion::Error::BadUrlDataFormat)
+  end
+
+  it "doesn't parse when passed bad data" do
+    expect(client.decode("test-test")[:parsed]).to be_false
+  end
+
+  it "parses when passed good data" do
+    expect(decode_json[:parsed]).to be_true
+  end
+
+  it "returns expected values when passed good unsigned data" do
+    hash = decode_json
+    expect(hash[:url]).to eq("http://test.com/test")
+    expect(hash[:signed]).to be_false
+    expect(hash[:key_presented]).to be_empty
+    expect(hash[:key_expected]).to be_empty
+    expect(hash[:key_verified]).to be_false
+  end
+
+  it "returns expected values when passed good signed data" do
+    hash = decode_json_signed
+    expect(hash[:url]).to eq("http://test.com/test")
+    expect(hash[:signed]).to be_true
+    expect(hash[:key_presented]).to eq(JSON_KEY)
+    expect(hash[:key_expected]).to eq(JSON_KEY)
+    expect(hash[:key_verified]).to be_true
+  end
+
+  it "returns expected values when passed badly signed data" do
+    hash = decode_json_bad_key
+    expect(hash[:url]).to eq("http://test.com/test")
+    expect(hash[:signed]).to be_true
+    expect(hash[:key_presented]).to eq(JSON_KEY_BAD)
+    expect(hash[:key_expected]).to eq(JSON_KEY)
+    expect(hash[:key_verified]).to be_false
+  end
+
+  it "decodes parameters as expected" do
+    enc = client.encode(HTML, {:b => 999})
+    data = enc.scan(/".*?\/.*?\/.*?\/.*?\/.*?\/(.*?)"/).first.first
+    result = client.decode(data)
+    expect(result[:test]).to eq("1234")
+    expect(result[:b]).to eq(999)
+  end
+
+  it "decodes parameters as expected when signed" do
+    enc = client_sign.encode(HTML, {:b => 999})
+    data = enc.scan(/".*?\/.*?\/.*?\/.*?\/.*?\/(.*?)"/).first.first
+    hash = client.decode(data)
+    expect(hash[:test]).to eq("1234")
+    expect(hash[:b]).to eq(999)
+  end
+
+end

data/spec/diversion/decode/params_decode_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe Diversion::Decode::Params do
+
+  include_context "params"
+
+  it "returns correct type for non-signed" do
+    expect(decode_params).to be_a Hash
+  end
+
+  it "returns correct type for signed" do
+    expect(decode_params_signed).to be_a Hash
+  end
+
+  it "raises when data format invalid" do
+   expect{client.decode("badparam=badvalue")}.to raise_error(Diversion::Error::BadUrlDataFormat)
+  end
+
+  it "raises when data format invalid" do
+   expect{client.decode("rubbish")}.to raise_error(Diversion::Error::BadUrlDataFormat)
+  end
+
+  it "raises when missing url data parameter" do
+    expect{client.decode("d=#{CGI::escape('badparam=badvalue')}")}.to raise_error(Diversion::Error::BadUrlDataFormat)
+  end
+
+  it "raises when missing url data parameter empty" do
+    expect{client.decode("d=#{CGI::escape('url=')}")}.to raise_error(Diversion::Error::BadUrlDataFormat)
+  end
+
+  it "returns expected values when passed good unsigned data" do
+    hash = decode_params
+    expect(hash[:url]).to eq("http://test.com/test")
+    expect(hash[:signed]).to be_false
+    expect(hash[:key_presented]).to be_empty
+    expect(hash[:key_expected]).to be_empty
+    expect(hash[:key_verified]).to be_false
+  end
+
+  it "returns expected values when passed good signed data" do
+    hash = decode_params_signed
+    expect(hash[:url]).to eq("http://test.com/test")
+    expect(hash[:signed]).to be_true
+    expect(hash[:key_presented]).to eq(PARAMS_KEY)
+    expect(hash[:key_expected]).to eq(PARAMS_KEY)
+    expect(hash[:key_verified]).to be_true
+  end
+
+  it "returns expected values when passed badly signed data" do
+    hash = decode_params_bad_key
+    expect(hash[:url]).to eq("http://test.com/test")
+    expect(hash[:signed]).to be_true
+    expect(hash[:key_presented]).to eq(PARAMS_KEY_BAD)
+    expect(hash[:key_expected]).to eq(PARAMS_KEY)
+    expect(hash[:key_verified]).to be_false
+  end
+
+  it "decodes parameters as expected" do
+    enc = client.encode(HTML, {:b => 999})
+    data = enc.scan(/".*?\/.*?\/.*?\/.*?\/.*?\/(.*?)"/).first.first[1..-1]
+    result = client.decode(data)
+    expect(result[:test]).to eq("1234")
+    expect(result[:b]).to eq("999")
+  end
+
+  it "decodes parameters as expected when signed" do
+    enc = client_sign.encode(HTML, {:b => 999})
+    data = enc.scan(/".*?\/.*?\/.*?\/.*?\/.*?\/(.*?)"/).first.first[1..-1]
+    hash = client.decode(data)
+    expect(hash[:test]).to eq("1234")
+    expect(hash[:b]).to eq("999")
+  end
+
+end

data/spec/diversion/decode_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Diversion::Decode do
+
+  # we use json encoding here but it doesn't matter as we're testing common functionality
+  include_context "json"
+  
+  it "raise ArgumentError if data.length == 0" do
+    expect{client.decode("")}.to raise_error(ArgumentError)
+  end
+
+end

data/spec/diversion/encode/json_encode_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Diversion::Encode::Json do
+
+  include_context "json"
+
+  it "returns correct type" do
+    expect(encode_email).to be_a String
+  end
+
+  it "uses correct path" do
+    expect(encode_json_html).to match(/http:\/\/localhost.domain\/redirect\/1\/[A-Za-z0-9].*\">test<\/a>/)
+  end
+
+  it "doesn't add port for 80" do
+    client.port = 80
+    expect(encode_json_html).to_not match(/http:\/\/localhost.domain:80\/redirect/)
+  end
+  
+  it "adds port number for non-80 port" do
+    client.port = 81
+    expect(encode_json_html).to match(/http:\/\/localhost.domain:81\/redirect/)
+  end
+
+  it "doesn't sign by default" do
+    expect(encode_json_html).to_not match(/-/)
+  end
+
+  it "signs correctly" do
+    client_sign.sign_length = 32
+    expect(encode_json_html_signed).to match(/-[A-Za-z0-9]{32}\"/)
+  end
+
+  it "observes sign_length" do
+    client_sign.sign_length = 2
+    expect(encode_json_html_signed).to match(/-[A-Za-z0-9]{2}\"/)
+  end
+
+end

data/spec/diversion/encode/params_encode_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Diversion::Encode::Params do
+
+  include_context "params"
+
+  it "returns correct type" do
+    expect(encode_email).to be_a String
+  end
+
+  it "uses correct path" do
+    expect(encode_params_html).to eq(html_params_encoded)
+  end
+
+  it "doesn't add port for 80" do
+    client.port = 80
+    expect(encode_params_html).to eq(html_params_encoded)
+  end
+  
+  it "adds port number for non-80 port" do
+    client.port = 81
+    expect(encode_params_html).to eq(html_params_encoded({:port => 81}))
+  end
+
+  it "doesn't sign by default" do
+    expect(encode_params_html).to eq(html_params_encoded)
+  end
+
+  it "signs correctly" do
+    client_sign.sign_length = 32
+    expect(encode_params_html_signed).to eq(html_params_encoded({:sign_length => DEFAULT_SIGN_LEN}))
+  end
+
+  it "observes sign_length" do
+    client_sign.sign_length = 2
+    expect(encode_params_html_signed).to eq(html_params_encoded({:sign_length => 2}))
+  end
+
+end

data/spec/diversion/encode_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Diversion::Encode do
+
+  # we use json encoding here but it doesn't matter as we're testing common functionality
+  include_context "json"
+  
+  it "ignores non-http uris" do
+    expect(encode_email).to include('mailto:jess@doesnotexist.domain')
+  end
+
+  it "converts http uris" do
+    expect(encode_email).to_not include('https://twitter.com/intent/tweet?in_reply_to=51113028241989632')
+  end
+
+  it "removes data attributes" do
+    expect(encode_email).to_not include('data-')
+  end
+
+  it "raises when signing key not set" do
+    client_sign.sign_key = nil
+    expect { encode_json_html_signed }.to raise_error(Diversion::Error::KeyMissingError)
+  end
+
+  it "raises when no uris defined" do
+    client.encode_uris = []
+    expect { encode_json_html_signed }.to raise_error(Diversion::Error::ConfigurationError)
+  end
+
+end

data/spec/diversion/mailer_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Mail::Message do
+
+  let(:multipart) { Mail::Message.new(fixture('sample_email.multipart').read).diversion }
+  let(:multipart_args) { Mail::Message.new(fixture('sample_email.multipart').read).diversion({:a => 1}, {:encode_uris => ['http']}) }
+  let(:text_only) { Mail::Message.new(fixture('sample_email.text').read).diversion }
+
+  it "replaces html part" do
+    expect(multipart.html_part.body).to include('<a href="http://localhost.domain/redirect/1/?d=url%3Dhttp%253A%252F%252Fwww.youtube.com%252Fwatch%253Fv%253DFE_9CzLCbkY">Dream of the 90s</a>')
+    expect(multipart.html_part.body).to include('<a href="http://localhost.domain/redirect/1/?d=url%3Dhttps%253A%252F%252Fwww.youtube.com%252Fwatch%253Fv%253DOyQ6pqPFwTI">Customers only</a>')
+  end
+
+  it "doesn't replace text part" do
+    expect(text_only.body).to include('http://www.youtube.com/watch?v=FE_9CzLCbkY')
+    expect(text_only.body).to include('http://www.youtube.com/watch?v=OyQ6pqPFwTI')
+  end
+
+  it "doesn't fail when only text part present" do
+    expect{text_only}.to_not raise_error
+  end
+
+  it "honors additional global data parameters" do
+    expect(multipart_args.html_part.body).to include('<a href="http://localhost.domain/redirect/1/?d=a%3D1%26url%3Dhttp%253A%252F%252Fwww.youtube.com%252Fwatch%253Fv%253DFE_9CzLCbkY">Dream of the 90s</a>')
+  end
+
+  it "honors additional config arguments" do
+    expect(multipart_args.html_part.body).to include('<a href="https://www.youtube.com/watch?v=OyQ6pqPFwTI">Customers only</a>')
+  end
+
+end