split 4.0.0.pre2 → 4.0.2

data/spec/metric_spec.rb

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/metric'
+
+require "spec_helper"
+require "split/metric"
 
 describe Split::Metric do
-  describe 'possible experiments' do
+  describe "possible experiments" do
     it "should load the experiment if there is one, but no metric" do
-      experiment = Split::ExperimentCatalog.find_or_create('color', 'red', 'blue')
-      expect(Split::Metric.possible_experiments('color')).to eq([experiment])
+      experiment = Split::ExperimentCatalog.find_or_create("color", "red", "blue")
+      expect(Split::Metric.possible_experiments("color")).to eq([experiment])
     end
 
     it "should load the experiments in a metric" do
-      experiment1 = Split::ExperimentCatalog.find_or_create('color', 'red', 'blue')
-      experiment2 = Split::ExperimentCatalog.find_or_create('size', 'big', 'small')
+      experiment1 = Split::ExperimentCatalog.find_or_create("color", "red", "blue")
+      experiment2 = Split::ExperimentCatalog.find_or_create("size", "big", "small")
 
-      metric = Split::Metric.new(:name => 'purchase', :experiments => [experiment1, experiment2])
+      metric = Split::Metric.new(name: "purchase", experiments: [experiment1, experiment2])
       metric.save
-      expect(Split::Metric.possible_experiments('purchase')).to include(experiment1, experiment2)
+      expect(Split::Metric.possible_experiments("purchase")).to include(experiment1, experiment2)
     end
 
     it "should load both the metric experiments and an experiment with the same name" do
-      experiment1 = Split::ExperimentCatalog.find_or_create('purchase', 'red', 'blue')
-      experiment2 = Split::ExperimentCatalog.find_or_create('size', 'big', 'small')
+      experiment1 = Split::ExperimentCatalog.find_or_create("purchase", "red", "blue")
+      experiment2 = Split::ExperimentCatalog.find_or_create("size", "big", "small")
 
-      metric = Split::Metric.new(:name => 'purchase', :experiments => [experiment2])
+      metric = Split::Metric.new(name: "purchase", experiments: [experiment2])
       metric.save
-      expect(Split::Metric.possible_experiments('purchase')).to include(experiment1, experiment2)
+      expect(Split::Metric.possible_experiments("purchase")).to include(experiment1, experiment2)
     end
   end
-
 end

data/spec/persistence/cookie_adapter_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 require "spec_helper"
-require 'rack/test'
+require "rack/test"
 
 describe Split::Persistence::CookieAdapter do
   subject { described_class.new(context) }
@@ -13,10 +14,24 @@ describe Split::Persistence::CookieAdapter do
       end
 
       it "handles invalid JSON" do
-        context.request.cookies[:split] = {
-          :value => '{"foo":2,',
-          :expires => Time.now
-        }
+        context.request.cookies["split"] = "{\"foo\":2,"
+
+        expect(subject["my_key"]).to be_nil
+        subject["my_key"] = "my_value"
+        expect(subject["my_key"]).to eq("my_value")
+      end
+
+      it "ignores valid JSON of invalid type (integer)" do
+        context.request.cookies["split"] = "2"
+
+        expect(subject["my_key"]).to be_nil
+        subject["my_key"] = "my_value"
+        expect(subject["my_key"]).to eq("my_value")
+      end
+
+      it "ignores valid JSON of invalid type (array)" do
+        context.request.cookies["split"] = "[\"foo\", \"bar\"]"
+
         expect(subject["my_key"]).to be_nil
         subject["my_key"] = "my_value"
         expect(subject["my_key"]).to eq("my_value")
@@ -56,7 +71,7 @@ describe Split::Persistence::CookieAdapter do
     end
 
     it "ensure other added cookies are not overriden" do
-      context.response.set_cookie 'dummy', 'wow'
+      context.response.set_cookie "dummy", "wow"
       subject["foo"] = "FOO"
       expect(context.response.headers["Set-Cookie"]).to include("dummy=wow")
       expect(context.response.headers["Set-Cookie"]).to include("split=")
@@ -77,7 +92,7 @@ describe Split::Persistence::CookieAdapter do
         controller.send(:"request=", ActionDispatch::Request.new({}))
       end
 
-      response = ActionDispatch::Response.new(200, {}, '').tap do |res|
+      response = ActionDispatch::Response.new(200, {}, "").tap do |res|
         res.request = controller.request
       end
 
@@ -100,7 +115,7 @@ describe Split::Persistence::CookieAdapter do
       expect(subject["foo"]).to eq("FOO")
       expect(subject["bar"]).to eq("BAR")
       cookie_jar = context.request.env["action_dispatch.cookies"]
-      expect(cookie_jar['split']).to eq("{\"foo\":\"FOO\",\"bar\":\"BAR\"}")
+      expect(cookie_jar["split"]).to eq('{"foo":"FOO","bar":"BAR"}')
     end
   end
 end

data/spec/persistence/dual_adapter_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Split::Persistence::DualAdapter do
-  let(:context) { 'some context' }
+  let(:context) { "some context" }
 
   let(:logged_in_adapter_instance) { double }
   let(:logged_in_adapter) do
@@ -14,8 +14,8 @@ describe Split::Persistence::DualAdapter do
     Class.new.tap { |c| allow(c).to receive(:new) { logged_out_adapter_instance } }
   end
 
-  context 'when fallback_to_logged_out_adapter is false' do
-    context 'when logged in' do
+  context "when fallback_to_logged_out_adapter is false" do
+    context "when logged in" do
       subject do
         described_class.with_config(
           logged_in: lambda { |context| true },
@@ -25,32 +25,32 @@ describe Split::Persistence::DualAdapter do
         ).new(context)
       end
 
-      it '#[]=' do
-        expect(logged_in_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
+      it "#[]=" do
+        expect(logged_in_adapter_instance).to receive(:[]=).with("my_key", "my_value")
         expect_any_instance_of(logged_out_adapter).not_to receive(:[]=)
-        subject['my_key'] = 'my_value'
+        subject["my_key"] = "my_value"
       end
 
-      it '#[]' do
-        expect(logged_in_adapter_instance).to receive(:[]).with('my_key') { 'my_value' }
+      it "#[]" do
+        expect(logged_in_adapter_instance).to receive(:[]).with("my_key") { "my_value" }
         expect_any_instance_of(logged_out_adapter).not_to receive(:[])
-        expect(subject['my_key']).to eq('my_value')
+        expect(subject["my_key"]).to eq("my_value")
       end
 
-      it '#delete' do
-        expect(logged_in_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
+      it "#delete" do
+        expect(logged_in_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
         expect_any_instance_of(logged_out_adapter).not_to receive(:delete)
-        expect(subject.delete('my_key')).to eq('my_value')
+        expect(subject.delete("my_key")).to eq("my_value")
       end
 
-      it '#keys' do
-        expect(logged_in_adapter_instance).to receive(:keys) { ['my_value'] }
+      it "#keys" do
+        expect(logged_in_adapter_instance).to receive(:keys) { ["my_value"] }
         expect_any_instance_of(logged_out_adapter).not_to receive(:keys)
-        expect(subject.keys).to eq(['my_value'])
+        expect(subject.keys).to eq(["my_value"])
       end
     end
 
-    context 'when logged out' do
+    context "when logged out" do
       subject do
         described_class.with_config(
           logged_in: lambda { |context| false },
@@ -60,34 +60,34 @@ describe Split::Persistence::DualAdapter do
         ).new(context)
       end
 
-      it '#[]=' do
+      it "#[]=" do
         expect_any_instance_of(logged_in_adapter).not_to receive(:[]=)
-        expect(logged_out_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
-        subject['my_key'] = 'my_value'
+        expect(logged_out_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        subject["my_key"] = "my_value"
       end
 
-      it '#[]' do
+      it "#[]" do
         expect_any_instance_of(logged_in_adapter).not_to receive(:[])
-        expect(logged_out_adapter_instance).to receive(:[]).with('my_key') { 'my_value' }
-        expect(subject['my_key']).to eq('my_value')
+        expect(logged_out_adapter_instance).to receive(:[]).with("my_key") { "my_value" }
+        expect(subject["my_key"]).to eq("my_value")
       end
 
-      it '#delete' do
+      it "#delete" do
         expect_any_instance_of(logged_in_adapter).not_to receive(:delete)
-        expect(logged_out_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
-        expect(subject.delete('my_key')).to eq('my_value')
+        expect(logged_out_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(subject.delete("my_key")).to eq("my_value")
       end
 
-      it '#keys' do
+      it "#keys" do
         expect_any_instance_of(logged_in_adapter).not_to receive(:keys)
-        expect(logged_out_adapter_instance).to receive(:keys) { ['my_value', 'my_value2'] }
-        expect(subject.keys).to eq(['my_value', 'my_value2'])
+        expect(logged_out_adapter_instance).to receive(:keys) { ["my_value", "my_value2"] }
+        expect(subject.keys).to eq(["my_value", "my_value2"])
       end
     end
   end
 
-  context 'when fallback_to_logged_out_adapter is true' do
-    context 'when logged in' do
+  context "when fallback_to_logged_out_adapter is true" do
+    context "when logged in" do
       subject do
         described_class.with_config(
           logged_in: lambda { |context| true },
@@ -97,33 +97,33 @@ describe Split::Persistence::DualAdapter do
         ).new(context)
       end
 
-      it '#[]=' do
-        expect(logged_in_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
-        expect(logged_out_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
-        expect(logged_out_adapter_instance).to receive(:[]).with('my_key') { nil }
-        subject['my_key'] = 'my_value'
+      it "#[]=" do
+        expect(logged_in_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        expect(logged_out_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        expect(logged_out_adapter_instance).to receive(:[]).with("my_key") { nil }
+        subject["my_key"] = "my_value"
       end
 
-      it '#[]' do
-        expect(logged_in_adapter_instance).to receive(:[]).with('my_key') { 'my_value' }
+      it "#[]" do
+        expect(logged_in_adapter_instance).to receive(:[]).with("my_key") { "my_value" }
         expect_any_instance_of(logged_out_adapter).not_to receive(:[])
-        expect(subject['my_key']).to eq('my_value')
+        expect(subject["my_key"]).to eq("my_value")
       end
 
-      it '#delete' do
-        expect(logged_in_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
-        expect(logged_out_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
-        expect(subject.delete('my_key')).to eq('my_value')
+      it "#delete" do
+        expect(logged_in_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(logged_out_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(subject.delete("my_key")).to eq("my_value")
       end
 
-      it '#keys' do
-        expect(logged_in_adapter_instance).to receive(:keys) { ['my_value'] }
-        expect(logged_out_adapter_instance).to receive(:keys) { ['my_value', 'my_value2'] }
-        expect(subject.keys).to eq(['my_value', 'my_value2'])
+      it "#keys" do
+        expect(logged_in_adapter_instance).to receive(:keys) { ["my_value"] }
+        expect(logged_out_adapter_instance).to receive(:keys) { ["my_value", "my_value2"] }
+        expect(subject.keys).to eq(["my_value", "my_value2"])
       end
     end
 
-    context 'when logged out' do
+    context "when logged out" do
       subject do
         described_class.with_config(
           logged_in: lambda { |context| false },
@@ -133,39 +133,39 @@ describe Split::Persistence::DualAdapter do
         ).new(context)
       end
 
-      it '#[]=' do
+      it "#[]=" do
         expect_any_instance_of(logged_in_adapter).not_to receive(:[]=)
-        expect(logged_out_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
-        expect(logged_out_adapter_instance).to receive(:[]).with('my_key') { nil }
-        subject['my_key'] = 'my_value'
+        expect(logged_out_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        expect(logged_out_adapter_instance).to receive(:[]).with("my_key") { nil }
+        subject["my_key"] = "my_value"
       end
 
-      it '#[]' do
+      it "#[]" do
         expect_any_instance_of(logged_in_adapter).not_to receive(:[])
-        expect(logged_out_adapter_instance).to receive(:[]).with('my_key') { 'my_value' }
-        expect(subject['my_key']).to eq('my_value')
+        expect(logged_out_adapter_instance).to receive(:[]).with("my_key") { "my_value" }
+        expect(subject["my_key"]).to eq("my_value")
       end
 
-      it '#delete' do
-        expect(logged_in_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
-        expect(logged_out_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
-        expect(subject.delete('my_key')).to eq('my_value')
+      it "#delete" do
+        expect(logged_in_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(logged_out_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(subject.delete("my_key")).to eq("my_value")
       end
 
-      it '#keys' do
-        expect(logged_in_adapter_instance).to receive(:keys) { ['my_value'] }
-        expect(logged_out_adapter_instance).to receive(:keys) { ['my_value', 'my_value2'] }
-        expect(subject.keys).to eq(['my_value', 'my_value2'])
+      it "#keys" do
+        expect(logged_in_adapter_instance).to receive(:keys) { ["my_value"] }
+        expect(logged_out_adapter_instance).to receive(:keys) { ["my_value", "my_value2"] }
+        expect(subject.keys).to eq(["my_value", "my_value2"])
       end
     end
   end
 
-  describe 'when errors in config' do
+  describe "when errors in config" do
     before { described_class.config.clear }
-    let(:some_proc) { ->{} }
+    let(:some_proc) { -> { } }
 
-    it 'when no logged in adapter' do
-      expect{
+    it "when no logged in adapter" do
+      expect {
         described_class.with_config(
           logged_in: some_proc,
           logged_out_adapter: logged_out_adapter
@@ -173,8 +173,8 @@ describe Split::Persistence::DualAdapter do
       }.to raise_error(StandardError, /:logged_in_adapter/)
     end
 
-    it 'when no logged out adapter' do
-      expect{
+    it "when no logged out adapter" do
+      expect {
         described_class.with_config(
           logged_in: some_proc,
           logged_in_adapter: logged_in_adapter
@@ -182,8 +182,8 @@ describe Split::Persistence::DualAdapter do
       }.to raise_error(StandardError, /:logged_out_adapter/)
     end
 
-    it 'when no logged in detector' do
-      expect{
+    it "when no logged in detector" do
+      expect {
         described_class.with_config(
           logged_in_adapter: logged_in_adapter,
           logged_out_adapter: logged_out_adapter

data/spec/persistence/redis_adapter_spec.rb

@@ -1,67 +1,67 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Persistence::RedisAdapter do
-
-  let(:context) { double(:lookup => 'blah') }
+  let(:context) { double(lookup: "blah") }
 
   subject { Split::Persistence::RedisAdapter.new(context) }
 
-  describe '#redis_key' do
+  describe "#redis_key" do
     before { Split::Persistence::RedisAdapter.reset_config! }
 
-    context 'default' do
-      it 'should raise error with prompt to set lookup_by' do
-        expect{Split::Persistence::RedisAdapter.new(context)}.to raise_error(RuntimeError)
+    context "default" do
+      it "should raise error with prompt to set lookup_by" do
+        expect { Split::Persistence::RedisAdapter.new(context) }.to raise_error(RuntimeError)
       end
     end
 
-    context 'config with key' do
+    context "config with key" do
       before { Split::Persistence::RedisAdapter.reset_config! }
-      subject { Split::Persistence::RedisAdapter.new(context, 'manual') }
+      subject { Split::Persistence::RedisAdapter.new(context, "manual") }
 
       it 'should be "persistence:manual"' do
-        expect(subject.redis_key).to eq('persistence:manual')
+        expect(subject.redis_key).to eq("persistence:manual")
       end
     end
 
     context 'config with lookup_by = proc { "block" }' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'block'}) }
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "block" }) }
 
       it 'should be "persistence:block"' do
-        expect(subject.redis_key).to eq('persistence:block')
+        expect(subject.redis_key).to eq("persistence:block")
       end
     end
 
-    context 'config with lookup_by = proc { |context| context.test }' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'block'}) }
-      let(:context) { double(:test => 'block') }
+    context "config with lookup_by = proc { |context| context.test }" do
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "block" }) }
+      let(:context) { double(test: "block") }
 
       it 'should be "persistence:block"' do
-        expect(subject.redis_key).to eq('persistence:block')
+        expect(subject.redis_key).to eq("persistence:block")
       end
     end
 
     context 'config with lookup_by = "method_name"' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => 'method_name') }
-      let(:context) { double(:method_name => 'val') }
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: "method_name") }
+      let(:context) { double(method_name: "val") }
 
       it 'should be "persistence:bar"' do
-        expect(subject.redis_key).to eq('persistence:val')
+        expect(subject.redis_key).to eq("persistence:val")
       end
     end
 
-    context 'config with namespace and lookup_by' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'frag'}, :namespace => 'namer') }
+    context "config with namespace and lookup_by" do
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "frag" }, namespace: "namer") }
 
       it 'should be "namer"' do
-        expect(subject.redis_key).to eq('namer:frag')
+        expect(subject.redis_key).to eq("namer:frag")
       end
     end
   end
 
-  describe '#find' do
-    before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'frag'}, :namespace => 'a_namespace') }
+  describe "#find" do
+    before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "frag" }, namespace: "a_namespace") }
 
     it "should create and user from a given key" do
       adapter = Split::Persistence::RedisAdapter.find(2)
@@ -69,8 +69,8 @@ describe Split::Persistence::RedisAdapter do
     end
   end
 
-  context 'functional tests' do
-    before { Split::Persistence::RedisAdapter.with_config(:lookup_by => 'lookup') }
+  context "functional tests" do
+    before { Split::Persistence::RedisAdapter.with_config(lookup_by: "lookup") }
 
     describe "#[] and #[]=" do
       it "should set and return the value for given key" do
@@ -94,6 +94,5 @@ describe Split::Persistence::RedisAdapter do
         expect(subject.keys).to match(["my_key", "my_second_key"])
       end
     end
-
   end
 end

data/spec/persistence/session_adapter_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Persistence::SessionAdapter do
-
-  let(:context) { double(:session => {}) }
+  let(:context) { double(session: {}) }
   subject { Split::Persistence::SessionAdapter.new(context) }
 
   describe "#[] and #[]=" do
@@ -28,5 +28,4 @@ describe Split::Persistence::SessionAdapter do
       expect(subject.keys).to match(["my_key", "my_second_key"])
     end
   end
-
 end

data/spec/persistence_spec.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Persistence do
-
   subject { Split::Persistence }
 
   describe ".adapter" do
@@ -30,5 +30,4 @@ describe Split::Persistence do
       end
     end
   end
-
 end

data/spec/redis_interface_spec.rb

@@ -1,42 +1,44 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Split::RedisInterface do
-  let(:list_name) { 'list_name' }
-  let(:set_name) { 'set_name' }
+  let(:list_name) { "list_name" }
+  let(:set_name) { "set_name" }
   let(:interface) { described_class.new }
 
-  describe '#persist_list' do
+  describe "#persist_list" do
     subject(:persist_list) do
       interface.persist_list(list_name, %w(a b c d))
     end
 
     specify do
       expect(persist_list).to eq %w(a b c d)
-      expect(Split.redis.lindex(list_name, 0)).to eq 'a'
-      expect(Split.redis.lindex(list_name, 1)).to eq 'b'
-      expect(Split.redis.lindex(list_name, 2)).to eq 'c'
-      expect(Split.redis.lindex(list_name, 3)).to eq 'd'
+      expect(Split.redis.lindex(list_name, 0)).to eq "a"
+      expect(Split.redis.lindex(list_name, 1)).to eq "b"
+      expect(Split.redis.lindex(list_name, 2)).to eq "c"
+      expect(Split.redis.lindex(list_name, 3)).to eq "d"
       expect(Split.redis.llen(list_name)).to eq 4
     end
 
-    context 'list is overwritten but not deleted' do
+    context "list is overwritten but not deleted" do
       specify do
         expect(persist_list).to eq %w(a b c d)
-        interface.persist_list(list_name, ['z'])
-        expect(Split.redis.lindex(list_name, 0)).to eq 'z'
+        interface.persist_list(list_name, ["z"])
+        expect(Split.redis.lindex(list_name, 0)).to eq "z"
         expect(Split.redis.llen(list_name)).to eq 1
       end
     end
   end
 
-  describe '#add_to_set' do
+  describe "#add_to_set" do
     subject(:add_to_set) do
-      interface.add_to_set(set_name, 'something')
+      interface.add_to_set(set_name, "something")
     end
 
     specify do
       add_to_set
-      expect(Split.redis.sismember(set_name, 'something')).to be true
+      expect(Split.redis.sismember(set_name, "something")).to be true
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
-ENV['RACK_ENV'] = "test"
 
-require 'rubygems'
-require 'bundler/setup'
+ENV["RACK_ENV"] = "test"
 
-require 'simplecov'
+require "rubygems"
+require "bundler/setup"
+
+require "simplecov"
 SimpleCov.start
 
-require 'split'
-require 'ostruct'
-require 'yaml'
+require "split"
+require "ostruct"
+require "yaml"
 
-Dir['./spec/support/*.rb'].each { |f| require f }
+Dir["./spec/support/*.rb"].each { |f| require f }
 
 module GlobalSharedContext
   extend RSpec::SharedContext
-  let(:mock_user){ Split::User.new(double(session: {})) }
+  let(:mock_user) { Split::User.new(double(session: {})) }
 
   before(:each) do
     Split.configuration = Split::Configuration.new
@@ -24,13 +25,14 @@ module GlobalSharedContext
     Split.redis.flushdb
     Split::Cache.clear
     @ab_user = mock_user
-    params = nil
+    @params = nil
   end
 end
 
 RSpec.configure do |config|
-  config.order = 'random'
+  config.order = "random"
   config.include GlobalSharedContext
+  config.raise_errors_for_deprecations!
 end
 
 def session
@@ -41,11 +43,11 @@ def params
   @params ||= {}
 end
 
-def request(ua = 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_6; de-de) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27')
+def request(ua = "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_6; de-de) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27")
   @request ||= begin
     r = OpenStruct.new
     r.user_agent = ua
-    r.ip = '192.168.1.1'
+    r.ip = "192.168.1.1"
     r
   end
 end