puppet_x_eos_eapi 0.2.0

data/spec/fixtures/fixture_show_snmp_user.yaml

@@ -0,0 +1,2 @@
+--- 
+  - output: "\nUser name      : jeff\nSecurity model : v3\nEngine ID      : f5717f00420008177800\nAuthentication : SHA\nPrivacy        : AES-128\nGroup          : developers\n\nUser name      : nigel\nSecurity model : v2c\nGroup          : sysops (not configured)\n\nUser name      : nigel\nSecurity model : v3\nEngine ID      : f5717f00420008177800\nAuthentication : SHA\nPrivacy        : AES-128\nGroup          : sysops\n"

data/spec/fixtures/fixture_show_snmp_user_raw_text.yaml

@@ -0,0 +1 @@
+--- "\nUser name      : jeff\nSecurity model : v3\nEngine ID      : f5717f00420008177800\nAuthentication : SHA\nPrivacy        : AES-128\nGroup          : developers\n\nUser name      : nigel\nSecurity model : v2c\nGroup          : sysops (not configured)\n\nUser name      : nigel\nSecurity model : v3\nEngine ID      : f5717f00420008177800\nAuthentication : SHA\nPrivacy        : AES-128\nGroup          : sysops\n"

data/spec/fixtures/fixture_show_vlan.json

@@ -0,0 +1,37 @@
+{
+  "jsonrpc": "2.0",
+  "result": [
+    {
+      "sourceDetail": "",
+      "vlans": {
+        "1": {
+          "status": "active",
+          "name": "default",
+          "interfaces": {
+            "Ethernet2": {
+              "privatePromoted": false
+            },
+            "Ethernet3": {
+              "privatePromoted": false
+            },
+            "Ethernet1": {
+              "privatePromoted": false
+            },
+            "Ethernet4": {
+              "privatePromoted": false
+            }
+          },
+          "dynamic": false
+        },
+        "3110": {
+          "status": "active",
+          "name": "VLAN3110",
+          "interfaces": {
+          },
+          "dynamic": false
+        }
+      }
+    }
+  ],
+  "id": "db8d1ea6-9f28-43e1-a71f-cac3df16d985"
+}

data/spec/fixtures/fixture_show_vlan_3110.json

@@ -0,0 +1,18 @@
+{
+  "jsonrpc": "2.0",
+  "result": [
+    {
+      "sourceDetail": "",
+      "vlans": {
+        "3110": {
+          "status": "active",
+          "name": "VLAN3110",
+          "interfaces": {
+          },
+          "dynamic": false
+        }
+      }
+    }
+  ],
+  "id": "ddccdc56-5def-4eb7-81dd-0bce075e7954"
+}

data/spec/fixtures/fixture_show_vlan_4000.json

@@ -0,0 +1,18 @@
+{
+  "jsonrpc": "2.0",
+  "id": "27f0a14d-c3bc-4bdd-b4cc-cd00e6127f07",
+  "error": {
+    "data": [
+      {
+        "sourceDetail": "",
+        "errors": [
+          "VLAN 4000 not found in current VLAN database"
+        ],
+        "vlans": {
+        }
+      }
+    ],
+    "message": "CLI command 1 of 1 'show vlan 4000' failed: could not run command",
+    "code": 1000
+  }
+}

data/spec/fixtures/fixture_snmp_host_opts.yaml

@@ -0,0 +1,11 @@
+--- 
+  !ruby/sym name: "127.0.0.4:private:10162:v2:informs"
+  !ruby/sym ensure: !ruby/sym absent
+  !ruby/sym port: 10162
+  !ruby/sym version: !ruby/sym v2
+  !ruby/sym type: !ruby/sym informs
+  !ruby/sym community: private
+  !ruby/sym username: 
+  !ruby/sym security: 
+  !ruby/sym vrf: 
+  !ruby/sym source_interface: 

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/.bundle/'
+end
+
+require 'puppet_x_eos_eapi'
+
+dir = File.expand_path(File.dirname(__FILE__))
+Dir["#{dir}/support/**/*.rb"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.include FixtureHelpers
+
+  # rspec configuration
+  config.mock_with :rspec do |rspec_config|
+    rspec_config.syntax = :expect
+  end
+end

data/spec/support/fixtures.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+require 'pathname'
+require 'yaml'
+require 'json'
+
+##
+# Fixtures implements a global container to store fixture data loaded from the
+# filesystem.
+class Fixtures
+  def self.[](name)
+    @fixtures[name]
+  end
+
+  def self.[]=(name, value)
+    @fixtures[name] = value
+  end
+
+  def self.clear
+    @fixtures = {}
+  end
+
+  clear
+
+  ##
+  # save an object and saves it as a fixture in the filesystem.
+  #
+  # @param [Symbol] key The fixture name without the `fixture_` prefix or
+  #   `.json` suffix.
+  #
+  # @param [Object] obj The object to serialize to JSON and write to the
+  #   fixture file.
+  #
+  # @option opts [String] :dir ('/path/to/fixtures') The fixtures directory,
+  #   defaults to the full path of spec/fixtures/ relative to the root of the
+  #   module.
+  def self.save(key, obj, opts = {})
+    dir = opts[:dir] || File.expand_path('../../fixtures', __FILE__)
+    file = Pathname.new(File.join(dir, "fixture_#{key}.yaml"))
+    fail ArgumentError, "Error, file #{file} exists" if file.exist?
+    File.open(file, 'w+') { |f| f.puts YAML.dump(obj) }
+  end
+end
+
+##
+# FixtureHelpers provides instance methods for RSpec test cases that aid in the
+# loading and caching of fixture data.
+module FixtureHelpers
+  ##
+  # fixture loads a JSON fixture from the spec/fixtures/ directory, prefixed
+  # with fixture_.  Given the name 'foo' the file
+  # `spec/fixtures/fixture_foo.json` will be loaded and returned.  This method
+  # is memoized across the life of the process.
+  #
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength,
+  # rubocop:disable Metrics/PerceivedComplexity
+  #
+  # @param [Symbol] key The fixture name without the `fixture_` prefix or
+  #   `.json` suffix.
+  #
+  # @option opts [String] :dir ('/path/to/fixtures') The fixtures directory,
+  #   defaults to the full path of spec/fixtures/ relative to the root of the
+  #   module.
+  #
+  # @option opts [String] :format (:ruby) The format to return the fixture in,
+  #   defaults to native Ruby objects.  :json will return a JSON string.
+  def fixture(key, opts = { format: :ruby })
+    if opts[:format] == :ruby
+      memo = Fixtures[key]
+      return memo if memo
+    end
+    dir = opts[:dir] || fixture_dir
+
+    yaml = Pathname.new(File.join(dir, "fixture_#{key}.yaml"))
+    json = Pathname.new(File.join(dir, "fixture_#{key}.json"))
+
+    data = if yaml.exist?; then YAML.load(File.read(yaml))
+           elsif json.exist?; then JSON.load(File.read(json))
+           else fail "could not load YAML or JSON fixture #{key} "\
+             "tried:\n  #{yaml}\n  #{json}"
+           end
+
+    Fixtures[key] = data
+
+    case opts[:format]
+    when :ruby then data
+    when :json then JSON.pretty_generate(data)
+    when :yaml then YAML.dump(data)
+    else fail ArgumentError, "unknown format #{opts[:format].inspect}"
+    end
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+  # rubocop:enable Metrics/PerceivedComplexity
+
+  ##
+  # fixture_dir returns the full path to the fixture directory
+  #
+  # @api public
+  #
+  # @return [String] the full path to the fixture directory
+  def fixture_dir
+    File.expand_path('../../fixtures', __FILE__)
+  end
+end

data/spec/unit/puppet_x/eos/eapi_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe PuppetX::Eos::Eapi do
+  let(:hostname) { 'localhost' }
+  let(:port) { 80 }
+  let(:username) { 'admin' }
+  let(:password) { 'puppet' }
+  let(:enable_pwd) { 'puppet' }
+  let(:config) do
+    {
+      hostname: hostname,
+      port: 80,
+      username: 'admin',
+      password: 'puppet'
+    }
+  end
+  let(:api) { PuppetX::Eos::Eapi.new(config) }
+
+  context 'when initializing a new EAPI instance' do
+    [:hostname, :port, :username, :password, :enable_pwd].each do |option|
+      it "initializes with #{option}" do
+        api = described_class.new(option => send(option))
+        expect(api.send(option)).to eq(send(option))
+      end
+    end
+
+    it 'defaults hostname to localhost' do
+      expect(subject.hostname).to eq('localhost')
+    end
+
+    it 'uses a non-ssl connnection' do
+      api = described_class.new(use_ssl: false)
+      expect(api.uri.to_s).to eq('http://localhost')
+    end
+
+    context 'when the command API unix domain socket exists' do
+      before :each do
+        fakepath = double(Pathname)
+        [:socket?, :readable?, :writable?].each do |method|
+          allow(fakepath).to receive(method).and_return(true)
+        end
+        expect(Pathname).to receive(:new).with('/var/run/command-api.sock')
+          .and_return(fakepath)
+      end
+
+      let(:default_instance_state) { described_class.new }
+
+      describe '#http' do
+        subject { default_instance_state.http }
+
+        it { is_expected.to be_a NetX::HTTPUnix }
+        it 'address is /var/run/command-api.sock' do
+          expect(subject.address).to eq '/var/run/command-api.sock'
+        end
+        it 'port is nil' do
+          expect(subject.port).to be_nil
+        end
+      end
+
+      describe '#socket' do
+        subject { default_instance_state.socket }
+        it { is_expected.to eq '/var/run/command-api.sock' }
+      end
+    end
+  end
+
+  describe '#uri' do
+    it 'returns a default uri string' do
+      expect(subject.uri.to_s).to eq('http://localhost')
+    end
+  end
+
+  describe '#http' do
+    it 'returns an instance of Net::HTTP' do
+      expect(subject.http).to be_a Net::HTTP
+    end
+  end
+
+  context '#request' do
+    subject { api.request(commands, format: format) }
+    let(:format) { 'json' }
+
+    describe 'request a single command' do
+      let(:commands) { 'foo' }
+
+      it 'returns a request object of len 1' do
+        expect(subject['params']['cmds']).to be_a Array
+        expect(subject['params']['cmds'].length).to eq 1
+        expect(subject).to be_a Hash
+      end
+    end
+
+    describe 'request a commands array' do
+      let(:commands) { %w(foo bar) }
+
+      it 'returns a request object hash of len 2' do
+        expect(subject['params']['cmds']).to be_a Array
+        expect(subject['params']['cmds'].length).to eq 2
+        expect(subject).to be_a Hash
+      end
+    end
+
+    describe 'request a commands array with text' do
+      let(:commands) { 'foo' }
+      let(:format) { 'text' }
+      it 'requets a reqest objct of format text' do
+        expect(subject['params']['format']).to eq 'text'
+      end
+    end
+  end
+
+  describe '#enable' do
+    context 'when sending a single command' do
+      subject { api.enable('foo') }
+
+      before do
+        allow(api).to receive(:execute)
+          .with(['foo'], {})
+          .and_return([{}])
+      end
+
+      it { is_expected.to be_a_kind_of Array }
+    end
+
+    context 'when sending a commands with format = "text"' do
+      subject { api.enable('foo', format: 'text') }
+
+      before do
+        allow(api).to receive(:execute)
+          .with(['foo'], format: 'text')
+          .and_return([{}])
+      end
+
+      it { is_expected.to be_a_kind_of Array }
+    end
+
+    context 'when sending an array of commands' do
+      subject { api.enable(%w(foo bar)) }
+
+      before do
+        allow(api).to receive(:execute)
+          .with(%w(foo bar), {})
+          .and_return([{}, {}])
+      end
+
+      it { is_expected.to be_a_kind_of Array }
+    end
+  end
+
+  describe '#config' do
+
+    context 'when sending a command' do
+      subject { api.config('foo') }
+
+      before do
+        allow(api).to receive(:enable)
+          .with(%w(configure foo))
+          .and_return([{}, {}])
+      end
+
+      it { is_expected.to be_a_kind_of Array }
+    end
+
+    context 'when sending an array of commands' do
+      subject { api.config(%w(foo bar)) }
+
+      before do
+        allow(api).to receive(:enable)
+          .with(%w(configure foo bar))
+          .and_return([{}, {}, {}])
+      end
+
+      it { is_expected.to be_a_kind_of Array }
+    end
+  end
+
+  describe '#execute' do
+  end
+
+  describe '#invoke' do
+  end
+end

data/spec/unit/puppet_x/eos/module_base_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe PuppetX::Eos::ModuleBase do
+  let(:api) { PuppetX::Eos::Eapi.new }
+
+  describe '#running_configuration' do
+    let :result do
+      [
+        {
+          'output'   => "! Fake running-config",
+          'warnings' => ['Command: show running-config']
+        }
+      ]
+    end
+
+    before :each do
+      allow(api).to receive(:enable).with('show running-config', format: 'text')
+        .and_return(result)
+    end
+
+    subject { described_class.new(api).running_configuration }
+
+    it { is_expected.to be_a String }
+    it { is_expected.to eq(result.last['output']) }
+  end
+end

data/spec/unit/puppet_x/eos/modules/daemon_spec.rb

@@ -0,0 +1,110 @@
+#
+# Copyright (c) 2014, Arista Networks, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#   Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+#
+#   Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+#
+#   Neither the name of Arista Networks nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ARISTA NETWORKS
+# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+# IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+require 'spec_helper'
+require 'puppet_x/eos/modules/daemon'
+
+describe PuppetX::Eos::Daemon do
+  let(:eapi) { double }
+  let(:instance) { PuppetX::Eos::Daemon.new eapi }
+
+  context 'when initializing a new Daemon instance' do
+    subject { instance }
+    it { is_expected.to be_a_kind_of PuppetX::Eos::Daemon }
+  end
+
+  context 'with Eapi#enable' do
+    before :each do
+      allow(eapi).to receive(:enable)
+        .with(commands, format: 'text')
+        .and_return(api_response)
+    end
+
+    context '#getall' do
+      subject { instance.getall }
+
+      let(:commands) { 'show running-config section daemon' }
+
+      let :api_response do
+        dir = File.dirname(__FILE__)
+        file = File.join(dir, 'fixtures/daemon_getall.json')
+        JSON.load(File.read(file))
+      end
+
+      describe 'retreiving daemons from running-config' do
+        it { is_expected.to be_a_kind_of Hash }
+
+        it 'has two entries' do
+          expect(subject.size).to eq 2
+        end
+      end
+    end
+  end
+
+  context 'with Eapi#config' do
+    before :each do
+      allow(eapi).to receive(:config)
+        .with(commands)
+        .and_return(api_response)
+    end
+
+    context '#create' do
+      subject { instance.create(name, command) }
+
+      let(:commands) { ["daemon #{name}", "command #{command}"] }
+      let(:api_response) { [{}, {}] }
+
+      describe 'configure agent=foo with command=/path/to/foo' do
+        before :each do
+          allow(File).to receive(:executable?)
+            .and_return(true)
+        end
+
+        let(:name) { 'foo' }
+        let(:command) { '/path/to/foo' }
+
+        it { is_expected.to be_truthy }
+      end
+    end
+
+    context '#delete' do
+      subject { instance.delete(name) }
+
+      let(:commands) { "no daemon #{name}" }
+      let(:api_response) { [{}] }
+
+      describe 'delete agent foo from the running-config' do
+        let(:name) { 'foo' }
+        it { is_expected.to be_truthy }
+      end
+    end
+  end
+end