flipper 0.28.2 → 1.0.0.pre

data/spec/flipper/cloud/dsl_spec.rb

@@ -0,0 +1,82 @@
+require 'flipper/cloud/configuration'
+require 'flipper/cloud/dsl'
+require 'flipper/adapters/operation_logger'
+require 'flipper/adapters/instrumented'
+
+RSpec.describe Flipper::Cloud::DSL do
+  it 'delegates everything to flipper instance' do
+    cloud_configuration = Flipper::Cloud::Configuration.new({
+      token: "asdf",
+      sync_secret: "tasty",
+    })
+    dsl = described_class.new(cloud_configuration)
+    expect(dsl.features).to eq(Set.new)
+    expect(dsl.enabled?(:foo)).to be(false)
+  end
+
+  it 'delegates sync to cloud configuration' do
+    stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
+      with({
+        headers: {
+          'Flipper-Cloud-Token'=>'asdf',
+        },
+      }).to_return(status: 200, body: '{"features": {}}', headers: {})
+    cloud_configuration = Flipper::Cloud::Configuration.new({
+      token: "asdf",
+      sync_secret: "tasty",
+    })
+    dsl = described_class.new(cloud_configuration)
+    dsl.sync
+    expect(stub).to have_been_requested
+  end
+
+  it 'delegates sync_secret to cloud configuration' do
+    cloud_configuration = Flipper::Cloud::Configuration.new({
+      token: "asdf",
+      sync_secret: "tasty",
+    })
+    dsl = described_class.new(cloud_configuration)
+    expect(dsl.sync_secret).to eq("tasty")
+  end
+
+  context "when sync_method is webhook" do
+    let(:local_adapter) do
+      Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+    end
+
+    let(:cloud_configuration) do
+      cloud_configuration = Flipper::Cloud::Configuration.new({
+        token: "asdf",
+        sync_secret: "tasty",
+        local_adapter: local_adapter
+      })
+    end
+
+    subject do
+      described_class.new(cloud_configuration)
+    end
+
+    it "sends reads to local adapter" do
+      subject.features
+      subject.enabled?(:foo)
+      expect(local_adapter.count(:features)).to be(1)
+      expect(local_adapter.count(:get)).to be(1)
+    end
+
+    it "sends writes to cloud and local" do
+      add_stub = stub_request(:post, "https://www.flippercloud.io/adapter/features").
+        with({headers: {'Flipper-Cloud-Token'=>'asdf'}}).
+        to_return(status: 200, body: '{}', headers: {})
+      enable_stub = stub_request(:post, "https://www.flippercloud.io/adapter/features/foo/boolean").
+        with(headers: {'Flipper-Cloud-Token'=>'asdf'}).
+        to_return(status: 200, body: '{}', headers: {})
+
+      subject.enable(:foo)
+
+      expect(local_adapter.count(:add)).to be(1)
+      expect(local_adapter.count(:enable)).to be(1)
+      expect(add_stub).to have_been_requested
+      expect(enable_stub).to have_been_requested
+    end
+  end
+end

data/spec/flipper/cloud/message_verifier_spec.rb

@@ -0,0 +1,104 @@
+require 'flipper/cloud/message_verifier'
+
+RSpec.describe Flipper::Cloud::MessageVerifier do
+  let(:payload) { "some payload" }
+  let(:secret) { "secret" }
+  let(:timestamp) { Time.now }
+
+  describe "#generate" do
+    it "generates signature that can be verified" do
+      message_verifier = Flipper::Cloud::MessageVerifier.new(secret: secret)
+      signature = message_verifier.generate(payload, timestamp)
+      header = generate_header(timestamp: timestamp, signature: signature)
+      expect(message_verifier.verify(payload, header)).to be(true)
+    end
+  end
+
+  describe "#header" do
+    it "generates a header in valid format" do
+      version = "v1"
+      message_verifier = Flipper::Cloud::MessageVerifier.new(secret: secret, version: version)
+      signature = message_verifier.generate(payload, timestamp)
+      header = message_verifier.header(signature, timestamp)
+      expect(header).to eq("t=#{timestamp.to_i},#{version}=#{signature}")
+    end
+  end
+
+  describe ".header" do
+    it "generates a header in valid format" do
+      version = "v1"
+      message_verifier = Flipper::Cloud::MessageVerifier.new(secret: secret, version: version)
+      signature = message_verifier.generate(payload, timestamp)
+
+      header = Flipper::Cloud::MessageVerifier.header(signature, timestamp, version)
+      expect(header).to eq("t=#{timestamp.to_i},#{version}=#{signature}")
+    end
+  end
+
+  describe "#verify" do
+    it "raises a InvalidSignature when the header does not have the expected format" do
+      header = "i'm not even a real signature header"
+      expect {
+        message_verifier = Flipper::Cloud::MessageVerifier.new(secret: "secret")
+        message_verifier.verify(payload, header)
+      }.to raise_error(Flipper::Cloud::MessageVerifier::InvalidSignature, "Unable to extract timestamp and signatures from header")
+    end
+
+    it "raises a InvalidSignature when there are no signatures with the expected version" do
+      header = generate_header(version: "v0")
+      expect {
+        message_verifier = Flipper::Cloud::MessageVerifier.new(secret: "secret")
+        message_verifier.verify(payload, header)
+      }.to raise_error(Flipper::Cloud::MessageVerifier::InvalidSignature, /No signatures found with expected version/)
+    end
+
+    it "raises a InvalidSignature when there are no valid signatures for the payload" do
+      header = generate_header(signature: "bad_signature")
+      expect {
+        message_verifier = Flipper::Cloud::MessageVerifier.new(secret: "secret")
+        message_verifier.verify(payload, header)
+      }.to raise_error(Flipper::Cloud::MessageVerifier::InvalidSignature, "No signatures found matching the expected signature for payload")
+    end
+
+    it "raises a InvalidSignature when the timestamp is not within the tolerance" do
+      header = generate_header(timestamp: Time.now - 15)
+      expect {
+        message_verifier = Flipper::Cloud::MessageVerifier.new(secret: secret)
+        message_verifier.verify(payload, header, tolerance: 10)
+      }.to raise_error(Flipper::Cloud::MessageVerifier::InvalidSignature, /Timestamp outside the tolerance zone/)
+    end
+
+    it "returns true when the header contains a valid signature and the timestamp is within the tolerance" do
+      header = generate_header
+      message_verifier = Flipper::Cloud::MessageVerifier.new(secret: "secret")
+      expect(message_verifier.verify(payload, header, tolerance: 10)).to be(true)
+    end
+
+    it "returns true when the header contains at least one valid signature" do
+      header = generate_header + ",v1=bad_signature"
+      message_verifier = Flipper::Cloud::MessageVerifier.new(secret: secret)
+      expect(message_verifier.verify(payload, header, tolerance: 10)).to be(true)
+    end
+
+    it "returns true when the header contains a valid signature and the timestamp is off but no tolerance is provided" do
+      header = generate_header(timestamp: Time.at(12_345))
+      message_verifier = Flipper::Cloud::MessageVerifier.new(secret: secret)
+      expect(message_verifier.verify(payload, header)).to be(true)
+    end
+  end
+
+  private
+
+  def generate_header(options = {})
+    options[:secret] ||= secret
+    options[:version] ||= "v1"
+
+    message_verifier = Flipper::Cloud::MessageVerifier.new(secret: options[:secret], version: options[:version])
+
+    options[:timestamp] ||= timestamp
+    options[:payload] ||= payload
+    options[:signature] ||= message_verifier.generate(options[:payload], options[:timestamp])
+
+    Flipper::Cloud::MessageVerifier.header(options[:signature], options[:timestamp], options[:version])
+  end
+end

data/spec/flipper/cloud/middleware_spec.rb

@@ -0,0 +1,289 @@
+require 'securerandom'
+require 'flipper/cloud'
+require 'flipper/cloud/middleware'
+require 'flipper/adapters/operation_logger'
+
+RSpec.describe Flipper::Cloud::Middleware do
+  let(:flipper) {
+    Flipper::Cloud.new(token: "regular") do |config|
+      config.local_adapter = Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
+      config.sync_secret = "regular_tasty"
+    end
+  }
+
+  let(:env_flipper) {
+    Flipper::Cloud.new(token: "env") do |config|
+      config.local_adapter = Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
+      config.sync_secret = "env_tasty"
+    end
+  }
+
+  let(:app) { Flipper::Cloud.app(flipper) }
+  let(:response_body) { JSON.generate({features: {}}) }
+  let(:request_body) {
+    JSON.generate({
+      "environment_id" => 1,
+      "webhook_id" => 1,
+      "delivery_id" => SecureRandom.uuid,
+      "action" => "sync",
+    })
+  }
+  let(:timestamp) { Time.now }
+  let(:signature) {
+    Flipper::Cloud::MessageVerifier.new(secret: flipper.sync_secret).generate(request_body, timestamp)
+  }
+  let(:signature_header_value) {
+    Flipper::Cloud::MessageVerifier.new(secret: "").header(signature, timestamp)
+  }
+
+  context 'when initializing middleware with flipper instance' do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it 'uses instance to sync' do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq({
+        "groups" => [
+          {"name" => "admins"},
+          {"name" => "staff"},
+          {"name" => "basic"},
+          {"name" => "plus"},
+          {"name" => "premium"},
+        ],
+      })
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when signature is invalid' do
+    let(:app) { Flipper::Cloud.app(flipper) }
+    let(:signature) {
+      Flipper::Cloud::MessageVerifier.new(secret: "nope").generate(request_body, timestamp)
+    }
+
+    it 'uses instance to sync' do
+      stub = stub_request_for_token('regular')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(400)
+      expect(stub).not_to have_been_requested
+    end
+  end
+
+  context "when flipper cloud responds with 402" do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it "results in 402" do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular', status: 402)
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(402)
+      expect(last_response.headers["Flipper-Cloud-Response-Error-Class"]).to eq("Flipper::Adapters::Http::Error")
+      expect(last_response.headers["Flipper-Cloud-Response-Error-Message"]).to include("Failed with status: 402")
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context "when flipper cloud responds with non-402 and non-2xx code" do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it "results in 500" do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular', status: 503)
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(500)
+      expect(last_response.headers["Flipper-Cloud-Response-Error-Class"]).to eq("Flipper::Adapters::Http::Error")
+      expect(last_response.headers["Flipper-Cloud-Response-Error-Message"]).to include("Failed with status: 503")
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context "when flipper cloud responds with timeout" do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it "results in 500" do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular', status: :timeout)
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(500)
+      expect(last_response.headers["Flipper-Cloud-Response-Error-Class"]).to eq("Net::OpenTimeout")
+      expect(last_response.headers["Flipper-Cloud-Response-Error-Message"]).to eq("execution expired")
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when initialized with flipper instance and flipper instance in env' do
+    let(:app) { Flipper::Cloud.app(flipper) }
+    let(:signature) {
+      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
+    }
+
+    it 'uses env instance to sync' do
+      stub = stub_request_for_token('env')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+        'flipper' => env_flipper,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when initialized without flipper instance but flipper instance in env' do
+    let(:app) { Flipper::Cloud.app }
+    let(:signature) {
+      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
+    }
+
+    it 'uses env instance to sync' do
+      stub = stub_request_for_token('env')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+        'flipper' => env_flipper,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when initialized with env_key' do
+    let(:app) { Flipper::Cloud.app(flipper, env_key: 'flipper_cloud') }
+    let(:signature) {
+      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
+    }
+
+    it 'uses provided env key instead of default' do
+      stub = stub_request_for_token('env')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+        'flipper' => flipper,
+        'flipper_cloud' => env_flipper,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when initializing lazily with a block' do
+    let(:app) { Flipper::Cloud.app(-> { flipper }) }
+
+    it 'works' do
+      stub = stub_request_for_token('regular')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when using older /webhooks path' do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it 'uses instance to sync' do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/webhooks', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq({
+        "groups" => [
+          {"name" => "admins"},
+          {"name" => "staff"},
+          {"name" => "basic"},
+          {"name" => "plus"},
+          {"name" => "premium"},
+        ],
+      })
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe 'Request method unsupported' do
+    it 'skips middleware' do
+      get '/'
+      expect(last_response.status).to eq(404)
+      expect(last_response.content_type).to eq("application/json")
+      expect(last_response.body).to eq("{}")
+    end
+  end
+
+  describe 'Inspecting the built Rack app' do
+    it 'returns a String' do
+      expect(Flipper::Cloud.app(flipper).inspect).to eq("Flipper::Cloud")
+    end
+  end
+
+  private
+
+  def stub_request_for_token(token, status: 200)
+    stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
+      with({
+        headers: {
+          'Flipper-Cloud-Token' => token,
+        },
+      })
+    if status == :timeout
+      stub.to_timeout
+    else
+      stub.to_return(status: status, body: response_body, headers: {})
+    end
+  end
+end

data/spec/flipper/cloud_spec.rb

@@ -0,0 +1,180 @@
+require 'flipper/cloud'
+require 'flipper/adapters/instrumented'
+require 'flipper/instrumenters/memory'
+
+RSpec.describe Flipper::Cloud do
+  before do
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+  end
+
+  context "initialize with token" do
+    let(:token) { 'asdf' }
+
+    before do
+      @instance = described_class.new(token: token)
+    end
+
+    it 'returns Flipper::DSL instance' do
+      expect(@instance).to be_instance_of(Flipper::Cloud::DSL)
+    end
+
+    it 'can read the cloud configuration' do
+      expect(@instance.cloud_configuration).to be_instance_of(Flipper::Cloud::Configuration)
+    end
+
+    it 'configures the correct adapter' do
+      # pardon the nesting...
+      memoized_adapter = @instance.adapter
+      dual_write_adapter = memoized_adapter.adapter
+      expect(dual_write_adapter).to be_instance_of(Flipper::Adapters::DualWrite)
+      poll_adapter = dual_write_adapter.local
+      expect(poll_adapter).to be_instance_of(Flipper::Adapters::Poll)
+
+      http_adapter = dual_write_adapter.remote
+      client = http_adapter.client
+      expect(client.uri.scheme).to eq('https')
+      expect(client.uri.host).to eq('www.flippercloud.io')
+      expect(client.uri.path).to eq('/adapter')
+      expect(client.headers['Flipper-Cloud-Token']).to eq(token)
+      expect(@instance.instrumenter).to be(Flipper::Instrumenters::Noop)
+    end
+  end
+
+  context 'initialize with token and options' do
+    it 'sets correct url' do
+      instance = described_class.new(token: 'asdf', url: 'https://www.fakeflipper.com/sadpanda')
+      # pardon the nesting...
+      memoized = instance.adapter
+      dual_write = memoized.adapter
+      remote = dual_write.remote
+      uri = remote.client.uri
+      expect(uri.scheme).to eq('https')
+      expect(uri.host).to eq('www.fakeflipper.com')
+      expect(uri.path).to eq('/sadpanda')
+    end
+  end
+
+  it 'can initialize with no token explicitly provided' do
+    with_env 'FLIPPER_CLOUD_TOKEN' => 'asdf' do
+      expect(described_class.new).to be_instance_of(Flipper::Cloud::DSL)
+    end
+  end
+
+  it 'can set instrumenter' do
+    instrumenter = Flipper::Instrumenters::Memory.new
+    instance = described_class.new(token: 'asdf', instrumenter: instrumenter)
+    expect(instance.instrumenter).to be(instrumenter)
+  end
+
+  it 'allows wrapping adapter with another adapter like the instrumenter' do
+    instance = described_class.new(token: 'asdf') do |config|
+      config.adapter do |adapter|
+        Flipper::Adapters::Instrumented.new(adapter)
+      end
+    end
+    # instance.adapter is memoizable adapter instance
+    expect(instance.adapter.adapter).to be_instance_of(Flipper::Adapters::Instrumented)
+  end
+
+  it 'can set debug_output' do
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(debug_output: STDOUT)).at_least(:once)
+    described_class.new(token: 'asdf', debug_output: STDOUT)
+  end
+
+  it 'can set read_timeout' do
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(read_timeout: 1)).at_least(:once)
+    described_class.new(token: 'asdf', read_timeout: 1)
+  end
+
+  it 'can set open_timeout' do
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(open_timeout: 1)).at_least(:once)
+    described_class.new(token: 'asdf', open_timeout: 1)
+  end
+
+  if RUBY_VERSION >= '2.6.0'
+    it 'can set write_timeout' do
+      expect(Flipper::Adapters::Http::Client).to receive(:new)
+        .with(hash_including(open_timeout: 1)).at_least(:once)
+      described_class.new(token: 'asdf', open_timeout: 1)
+    end
+  end
+
+  it 'can import' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'Flipper-Cloud-Token'=>'asdf'}).to_return(status: 200, body: "{}", headers: {})
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    cloud_flipper.import(flipper)
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect(cloud_flipper.adapter.get_all).to eq(get_all)
+  end
+
+  it 'raises error for failure while importing' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'Flipper-Cloud-Token'=>'asdf'}).to_return(status: 500, body: "{}")
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect { cloud_flipper.import(flipper) }.to raise_error(Flipper::Adapters::Http::Error)
+    expect(flipper.adapter.get_all).to eq(get_all)
+  end
+
+  it 'raises error for timeout while importing' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'Flipper-Cloud-Token'=>'asdf'}).to_timeout
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect { cloud_flipper.import(flipper) }.to raise_error(Net::OpenTimeout)
+    expect(flipper.adapter.get_all).to eq(get_all)
+  end
+end