cisco_node_utils 1.2.0 → 1.3.0

data/tests/test_command_reference.rb

@@ -34,17 +34,6 @@ class TestCmdRef < Minitest::Test
     @input_file.close!
   end
 
-  # Extend standard Minitest error handling to report UnsupportedError as skip
-  def capture_exceptions
-    super do
-      begin
-        yield
-      rescue Cisco::UnsupportedError => e
-        skip(e.to_s)
-      end
-    end
-  end
-
   def load_file(**args)
     CommandReference.new(**args, :files => [@input_file.path])
   end
@@ -57,11 +46,28 @@ class TestCmdRef < Minitest::Test
   def test_data_sanity
     # Make sure the actual YAML in our library loads for various platforms
     CommandReference.new
-    CommandReference.new(platform: :nexus, cli: true)
-    CommandReference.new(platform: :nexus, product: 'N9K-C9396PX', cli: true)
-    CommandReference.new(platform: :nexus, product: 'N7K-C7010', cli: true)
-    CommandReference.new(platform: :nexus, product: 'N3K-C3064PQ-10GE',
-                         cli: true)
+
+    CommandReference.new(platform:     :nexus,
+                         data_formats: [:nxapi_structured, :cli])
+
+    CommandReference.new(platform:     :nexus,
+                         product:      'N9K-C9396PX',
+                         data_formats: [:nxapi_structured, :cli])
+
+    CommandReference.new(platform:     :nexus,
+                         product:      'N7K-C7010',
+                         data_formats: [:nxapi_structured, :cli])
+
+    CommandReference.new(platform:     :nexus,
+                         product:      'N3K-C3064PQ-10GE',
+                         data_formats: [:nxapi_structured, :cli])
+
+    CommandReference.new(platform:     :ios_xr,
+                         data_formats: [:cli])
+
+    CommandReference.new(platform:     :ios_xr,
+                         product:      'R-IOSXRV9000-CH',
+                         data_formats: [:cli])
   end
 
   def test_load_empty_file
@@ -107,7 +113,7 @@ name:
 name:
   default_value: false
 name:
-  config_get: 'show feature'")
+  get_command: 'show feature'")
     assert_raises(RuntimeError) { load_file }
   end
 
@@ -122,7 +128,7 @@ name:
   def test_load_unsupported_key
     write("
 name:
-  config_get: 'show feature'
+  get_command: 'show feature'
   what_is_this: \"I don't even\"")
     assert_raises(RuntimeError) { load_file }
   end
@@ -137,86 +143,145 @@ name_a:
   end
 
   def type_check(obj, cls)
-    assert(obj.is_a?(cls), "#{obj} should be #{cls} but is #{obj.class}")
+    assert(obj.is_a?(cls), "'#{obj}' type should be #{cls} but is #{obj.class}")
   end
 
   def test_load_types
     write(%q(
 name:
   default_value: true
-  config_get: show hello
-  config_get_token: '/hello world/'
-  config_set: [ \"hello\", \"world\" ]
-  test_config_get_regex: '/hello world/'
-  test_config_result:
-    false: RuntimeError
-    32: "Long VLAN name knob is not enabled"
-    nil: ~
+  get_command: show hello
+  get_context: ['/hello/i']
+  get_value: '/world/'
+  set_context: [ "hello", "world" ]
+  set_value:
+    - "hello"
+    - "world"
 ))
     reference = load_file
     ref = reference.lookup('test', 'name')
     type_check(ref.default_value, TrueClass)
-    type_check(ref.config_get, String)
-    type_check(ref.config_get_token, Array)
-    type_check(ref.config_get_token[0], Regexp)
-    type_check(ref.config_set, Array)
-    type_check(ref.test_config_get_regex, Regexp)
-    assert_raises(IndexError) { ref.test_config_get }
-    type_check(ref.test_config_result(false), RuntimeError.class)
-    type_check(ref.test_config_result(32), String)
-    type_check(ref.test_config_result('nil'), NilClass)
+    type_check(ref.get_command, String)
+    type_check(ref.get_context, Array)
+    type_check(ref.get_context[0], String)
+    type_check(ref.get_value, String)
+    type_check(ref.set_context, Array)
+    type_check(ref.set_context[0], String)
+    type_check(ref.set_value, Array)
+    type_check(ref.set_value[0], String)
+    assert_raises(IndexError) { ref.context }
 
     assert(ref.default_value?)
-    assert(ref.config_get?)
-    assert(ref.config_get_token?)
-    assert(ref.config_set?)
+    assert(ref.get_command?)
+    assert(ref.get_context?)
+    assert(ref.get_value?)
+    assert(ref.getter?)
+    assert(ref.set_context?)
+    assert(ref.set_value?)
+    assert(ref.setter?)
   end
 
   def write_variants
     write("
 name:
   default_value: 'generic'
-  cli_nexus:
+  nexus:
     default_value: 'NXAPI base'
-    /N7K/:
+    C3064:
+      default_value: 'NXAPI C3064'
+    C3132:
+      default_value: 'NXAPI C3132'
+    C3172:
+      default_value: 'NXAPI C3172'
+    N7k:
       default_value: ~
-    /N9K/:
+    N9k:
       default_value: 'NXAPI N9K'
+  ios_xr:
+    XRv9k:
+      default_value: ~
+    else:
+      default_value: 'gRPC base'
 ")
   end
 
   def test_load_generic
     write_variants
+    # Neither NXAPI nor gRPC
     reference = load_file
     assert_equal('generic', reference.lookup('test', 'name').default_value)
   end
 
   def test_load_n9k
     write_variants
-    reference = load_file(platform: :nexus, product: 'N9K-C9396PX', cli: true)
+    reference = load_file(platform:     :nexus,
+                          product:      'N9K-C9396PX',
+                          data_formats: [:nxapi_structured, :cli])
     assert_equal('NXAPI N9K', reference.lookup('test', 'name').default_value)
   end
 
   def test_load_n7k
     write_variants
-    reference = load_file(platform: :nexus, product: 'N7K-C7010', cli: true)
+    reference = load_file(platform:     :nexus,
+                          product:      'N7K-C7010',
+                          data_formats: [:nxapi_structured, :cli])
     assert_equal(nil, reference.lookup('test', 'name').default_value)
   end
 
-  def test_load_n3k_3064
+  def test_load_n3k
     write_variants
-    reference = load_file(platform: :nexus, product: 'N3K-C3064PQ-10GE',
-                          cli: true)
+    reference = load_file(platform:     :nexus,
+                          product:      'N3K',
+                          data_formats: [:nxapi_structured, :cli])
     assert_equal('NXAPI base', reference.lookup('test', 'name').default_value)
   end
 
+  def test_load_n3k_3064
+    write_variants
+    reference = load_file(platform:     :nexus,
+                          product:      'N3K-C3064PQ-10GE',
+                          data_formats: [:nxapi_structured, :cli])
+    assert_equal('NXAPI C3064', reference.lookup('test', 'name').default_value)
+  end
+
+  def test_load_n3k_3132
+    write_variants
+    reference = load_file(platform:     :nexus,
+                          product:      'N3K-C3132Q-40GE',
+                          data_formats: [:nxapi_structured, :cli])
+    assert_equal('NXAPI C3132', reference.lookup('test', 'name').default_value)
+  end
+
+  def test_load_n3k_3172
+    write_variants
+    reference = load_file(platform:     :nexus,
+                          product:      'N3K-C3172PQ-10GE',
+                          data_formats: [:nxapi_structured, :cli])
+    assert_equal('NXAPI C3172', reference.lookup('test', 'name').default_value)
+  end
+
+  def test_load_ios_xr_xrv9k
+    write_variants
+    reference = load_file(platform:     :ios_xr,
+                          product:      'R-IOSXRV9000-CH',
+                          data_formats: [:cli])
+    assert_nil(reference.lookup('test', 'name').default_value)
+  end
+
+  def test_load_ios_xr_generic
+    write_variants
+    reference = load_file(platform:     :ios_xr,
+                          data_formats: [:cli])
+    assert_equal('gRPC base', reference.lookup('test', 'name').default_value)
+  end
+
   def write_exclusions
     write("
 _exclude:
-  - /N9K/
+  - N9k
 
 name:
-  _exclude: [/C30../, /C31../]
+  _exclude: [N3k]
   default_value: hello
 
 rank:
@@ -232,16 +297,20 @@ rank:
     # default_value is nil for an unsupported property
     assert(ref.default_value?, 'default_value? returned false')
     assert_nil(ref.default_value)
-    refute(ref.config_get?)
-    assert_raises(Cisco::UnsupportedError) { ref.config_get }
+    refute(ref.getter?)
+    assert_raises(Cisco::UnsupportedError) { ref.getter }
+    refute(ref.setter?)
+    assert_raises(Cisco::UnsupportedError) { ref.setter }
 
     # Because the whole file is excluded, we don't know which
     # attributes are 'valid' - so any attribute name is permitted:
     ref = reference.lookup('test', 'foobar')
     assert(ref.default_value?)
     assert_nil(ref.default_value)
-    refute(ref.config_get?)
-    assert_raises(Cisco::UnsupportedError) { ref.config_get }
+    refute(ref.getter?)
+    assert_raises(Cisco::UnsupportedError) { ref.getter }
+    refute(ref.setter?)
+    assert_raises(Cisco::UnsupportedError) { ref.setter }
   end
 
   def test_exclude_whole_item
@@ -252,8 +321,10 @@ rank:
     ref = reference.lookup('test', 'name')
     assert(ref.default_value?)
     assert_nil(ref.default_value)
-    refute(ref.config_get?)
-    assert_raises(Cisco::UnsupportedError) { ref.config_get }
+    refute(ref.getter?)
+    assert_raises(Cisco::UnsupportedError) { ref.getter }
+    refute(ref.setter?)
+    assert_raises(Cisco::UnsupportedError) { ref.setter }
   end
 
   def test_exclude_no_exclusion
@@ -264,12 +335,13 @@ rank:
   end
 
   def test_exclude_implicit
+    # TODO: something is hinky with this test.
     write("
 name:
-  cli_nexus:
+  cli:
     default_value: 1
 ")
-    reference = load_file(platform: 'nexus', cli: false)
+    reference = load_file(platform: 'nexus', data_formats: [])
     ref = reference.lookup('test', 'name')
     assert(ref.default_value?)
     assert_nil(ref.default_value)
@@ -285,27 +357,31 @@ name:
     assert(ref.default_only?)
     assert(ref.default_value?)
     assert_equal('x', ref.default_value)
-    refute(ref.config_set?)
-    assert_raises(Cisco::UnsupportedError) { ref.config_set }
+    refute(ref.getter?)
+    assert_raises(Cisco::UnsupportedError) { ref.getter }
+    refute(ref.setter?)
+    assert_raises(Cisco::UnsupportedError) { ref.setter }
   end
 
   def test_default_only_cleanup
     write("
 name:
   default_only: 'x'
-  config_set: 'foo'
+  set_value: 'foo'
 ")
     reference = load_file
     ref = reference.lookup('test', 'name')
     assert(ref.default_only?)
     assert(ref.default_value?)
     assert_equal('x', ref.default_value)
-    refute(ref.config_set?)
-    assert_raises(Cisco::UnsupportedError) { ref.config_set }
+    refute(ref.set_value?)
+    assert_raises(Cisco::UnsupportedError) { ref.set_value }
+    refute(ref.setter?)
+    assert_raises(Cisco::UnsupportedError) { ref.setter }
 
     write("
 name2:
-  config_set: 'foo'
+  set_value: 'foo'
   default_only: 'x'
 ")
     reference = load_file
@@ -313,17 +389,19 @@ name2:
     assert(ref.default_only?)
     assert(ref.default_value?)
     assert_equal('x', ref.default_value)
-    refute(ref.config_set?)
-    assert_raises(Cisco::UnsupportedError) { ref.config_set }
+    refute(ref.set_value?)
+    assert_raises(Cisco::UnsupportedError) { ref.set_value }
+    refute(ref.setter?)
+    assert_raises(Cisco::UnsupportedError) { ref.setter }
   end
 
   def test_default_only_default_value
     write("
 name:
   kind: int
-  cli_nexus:
+  nexus:
     default_value: 10
-    config_set: 'hello'
+    set_value: 'hello'
   default_only: 0
 ")
     reference = load_file
@@ -331,61 +409,261 @@ name:
     assert(ref.default_only?)
     assert(ref.default_value?)
     assert_equal(0, ref.default_value)
-    refute(ref.config_set?)
-    assert_raises(Cisco::UnsupportedError) { ref.config_set }
+    refute(ref.set_value?)
+    assert_raises(Cisco::UnsupportedError) { ref.set_value }
+    refute(ref.setter?)
+    assert_raises(Cisco::UnsupportedError) { ref.setter }
 
-    reference = load_file(cli: true, platform: 'nexus')
+    reference = load_file(data_formats: [:nxapi_structured, :cli],
+                          platform:     'nexus')
     ref = reference.lookup('test', 'name')
     refute(ref.default_only?)
     assert(ref.default_value?)
     assert_equal(10, ref.default_value)
-    assert(ref.config_set?)
-    assert_raises(IndexError) { ref.config_get }
+    assert(ref.set_value?)
+    assert(ref.setter?)
+    assert_raises(IndexError) { ref.get_value }
   end
 
-  def test_config_get_token_hash_substitution
+  def test_getter_hash_substitution
     write(%q(
 name:
-  config_get_token:
+  get_context:
     ['/^router ospf <name>$/',
-     '/^vrf <vrf>$/',
-     '/^router-id (\S+)$/']
+     '(?)/^vrf <vrf>$/']
+  get_value: '/^router-id (\S+)$/'
 test2:
-  config_get_token:
-    ['abc <val1> def',
-     'xyz <val2>']
+  get_context: ['(?)abc <val1> def']
+  get_value: 'xyz <val2>'
+test3:
+  get_context: ['foo']
+  # no get_value
+test4:
+  get_value: 'xyz <val1> <val2>'
 ))
     reference = load_file
     ref = reference.lookup('test', 'name')
-    token = ref.config_get_token(name: 'red')
-    assert_equal([/^router ospf red$/, /^router-id (\S+)$/],
-                 token)
-    token = ref.config_get_token(name: 'blue', vrf: 'green')
-    assert_equal([/^router ospf blue$/, /^vrf green$/, /^router-id (\S+)$/],
-                 token)
-    ref = reference.lookup('test', 'test2')
-    token = ref.config_get_token(val1: '1', val2: '2')
-    assert_equal(['abc 1 def', 'xyz 2'], token)
-    token = ref.config_get_token(val1: '1', extra_val: 'asdf')
-    assert_equal(['abc 1 def'], token)
-    token = ref.config_get_token(val2: '2')
-    assert_equal(['xyz 2'], token)
-    assert_raises(ArgumentError) { token = ref.config_get_token }
-    assert_raises(ArgumentError) { token = ref.config_get_token(extra: 'x') }
-  end
+    # vrf context is flagged as optional
+    getter = ref.getter(name: 'red')
+    assert_equal({
+                   command:     nil,
+                   context:     ['/^router ospf red$/'],
+                   value:       '/^router-id (\S+)$/',
+                   data_format: :cli,
+                 }, getter)
+
+    getter = ref.getter(name: 'blue', vrf: 'green')
+    assert_equal({
+                   command:     nil,
+                   context:     ['/^router ospf blue$/', '/^vrf green$/'],
+                   value:       '/^router-id (\S+)$/',
+                   data_format: :cli,
+                 }, getter)
+
+    # ospf name is not flagged as optional
+    assert_raises(ArgumentError) { ref.getter(vrf: 'green') }
 
-  def test_config_get_token_printf_substitution
+    ref = reference.lookup('test', 'test2')
+    getter = ref.getter(val1: '1', val2: '2')
+    assert_equal({
+                   command:     nil,
+                   context:     ['abc 1 def'],
+                   value:       'xyz 2',
+                   data_format: :cli,
+                 }, getter)
+
+    # value params are mandatory
+    assert_raises(ArgumentError) { ref.getter(val1: '1', extra_val: 'asdf') }
+
+    # context params are optional only if flagged!
+    getter = ref.getter(val2: '2')
+    assert_equal({
+                   command:     nil,
+                   context:     [],
+                   value:       'xyz 2',
+                   data_format: :cli,
+                 }, getter)
+
+    e = assert_raises(ArgumentError) { ref.getter }
+    assert_equal("No value specified for 'val2' in 'xyz <val2>'", e.message)
+
+    e = assert_raises(ArgumentError) { ref.getter(extra: 'x') }
+    assert_equal("No value specified for 'val2' in 'xyz <val2>'", e.message)
+
+    e = assert_raises(ArgumentError) { ref.getter('x') }
+    assert_match(/requires keyword args/, e.message)
+
+    # No get_value and no get_command means no getter
+    ref = reference.lookup('test', 'test3')
+    refute(ref.getter?)
+    assert_raises(UnsupportedError) { ref.getter }
+    assert_raises(UnsupportedError) { ref.getter(val1: '1') }
+    assert_raises(UnsupportedError) { ref.getter('x') }
+
+    # Multiple keys in a single parameter
+    ref = reference.lookup('test', 'test4')
+    getter = ref.getter(val1: 1, val2: 2.2)
+    assert_equal({
+                   command:     nil,
+                   context:     [],
+                   value:       'xyz 1 2.2',
+                   data_format: :cli,
+                 }, getter)
+
+    e = assert_raises(ArgumentError) { ref.getter }
+    assert_match(/No value specified for 'val1'/, e.message)
+    e = assert_raises(ArgumentError) { ref.getter(val1: 1) }
+    assert_equal("No value specified for 'val2' in 'xyz 1 <val2>'", e.message)
+    e = assert_raises(ArgumentError) { ref.getter(val2: 2.2) }
+    assert_equal("No value specified for 'val1' in 'xyz <val1> 2.2'", e.message)
+  end
+
+  def test_getter_printf_substitution
     write("
 name:
-  config_get_token: ['/^interface %s$/i', '/^description (.*)/']
+  get_context: ['/^interface %s$/i']
+  get_value: '/^description (.*)/'
+test3:
+  get_context: ['/^foo %s$/']
+  # no get_value
 ")
     reference = load_file
     ref = reference.lookup('test', 'name')
-    token = ref.config_get_token('Ethernet1/1')
-    assert_equal([%r{^interface Ethernet1/1$}i, /^description (.*)/],
-                 token)
+    getter = ref.getter('Ethernet1/1')
+    assert_equal({
+                   command:     nil,
+                   context:     ['/^interface Ethernet1/1$/i'],
+                   value:       '/^description (.*)/',
+                   data_format: :cli,
+                 }, getter)
     # Negative tests - wrong # of args
-    assert_raises(ArgumentError) { ref.config_get_token }
-    assert_raises(ArgumentError) { ref.config_get_token('eth1/1', 'foo') }
+    e = assert_raises(ArgumentError) { ref.getter }
+    assert_equal('wrong number of arguments (0 for 1)', e.message)
+
+    e = assert_raises(ArgumentError) { ref.getter('eth1/1', 'foo') }
+    assert_equal('wrong number of arguments (2 for 1)', e.message)
+
+    # Wrong kind of args
+    e = assert_raises(ArgumentError) { ref.getter(name: 'eth1/1', val: 'foo') }
+    assert_match(/requires positional args/, e.message)
+
+    ref = reference.lookup('test', 'test3')
+    refute(ref.getter?)
+    assert_raises(UnsupportedError) { ref.getter }
+    assert_raises(UnsupportedError) { ref.getter('1') }
+    assert_raises(UnsupportedError) { ref.getter(foo: '1') }
+  end
+
+  RAW_1 = {
+    'name' => {
+      '_exclude'      => ['N3k'],
+      'default_value' => 'generic',
+      'nexus'         => {
+        'default_value' => 'NXAPI base',
+        'N7k'           => { 'default_value' => nil },
+        'N9k'           => { 'default_value' => 'NXAPI N9K' },
+      },
+      'ios_xr'        => {
+        'XRv9k' => { 'default_value' => nil },
+        'else'  => { 'default_value' => 'gRPC base' },
+      },
+    }
+  }
+
+  FILTERED_1_NEXUS = {
+    'name' => {
+      'default_value' => 'generic',
+      'nexus'         => { 'default_value' => 'NXAPI base' },
+    }
+  }
+
+  FILTERED_1_NEXUS_N7K = {
+    'name' => {
+      'default_value' => 'generic',
+      'nexus'         => {
+        'default_value' => 'NXAPI base',
+        'N7k'           => { 'default_value' => nil },
+      },
+    }
+  }
+
+  FILTERED_1_NEXUS_N3K = {
+    'name' => {}
+  }
+
+  RAW_2 = {
+    '_template' => {
+      'ios_xr' => {
+        'cli'       => { 'get_command' => 'show inventory' },
+        'set_value' => 'show inventory',
+      },
+      'nexus'  => {
+        'nxapi_structured' => { get_command: 'show inventory' },
+        'set_value'        => 'show inventory | no-more',
+      },
+    }
+  }
+
+  FILTERED_2_IOS_XR = {
+    '_template' => {
+      'ios_xr' => {
+        'set_value' => 'show inventory'
+      }
+    }
+  }
+
+  FILTERED_2_IOS_XR_CLI = {
+    '_template' => {
+      'ios_xr' => {
+        'cli'       => { 'get_command' => 'show inventory' },
+        'set_value' => 'show inventory',
+      }
+    }
+  }
+
+  def test_filter_hash
+    filtered = CommandReference.filter_hash(RAW_1)
+    assert_equal({ 'name' => { 'default_value' => 'generic' } }, filtered)
+
+    filtered = CommandReference.filter_hash(RAW_1,
+                                            platform: :nexus)
+    assert_equal(FILTERED_1_NEXUS, filtered)
+
+    filtered = CommandReference.filter_hash(RAW_1,
+                                            platform:   :nexus,
+                                            product_id: 'N7K-C7010')
+    assert_equal(FILTERED_1_NEXUS_N7K, filtered)
+
+    filtered = CommandReference.filter_hash(RAW_1,
+                                            platform:   :nexus,
+                                            product_id: 'N3K-C3172PQ')
+    assert_equal(FILTERED_1_NEXUS_N3K, filtered)
+
+    filtered = CommandReference.filter_hash(RAW_2)
+    assert_equal({ '_template' => {} }, filtered)
+
+    filtered = CommandReference.filter_hash(RAW_2,
+                                            platform: :ios_xr)
+    assert_equal(FILTERED_2_IOS_XR, filtered)
+
+    filtered = CommandReference.filter_hash(RAW_2,
+                                            platform:     :ios_xr,
+                                            data_formats: [:cli])
+    assert_equal(FILTERED_2_IOS_XR_CLI, filtered)
+  end
+
+  def test_hash_merge_no_template
+    merged = CommandReference.hash_merge(FILTERED_1_NEXUS)
+    assert_equal({ 'default_value' => 'NXAPI base' }, merged)
+
+    merged = CommandReference.hash_merge(FILTERED_1_NEXUS_N7K)
+    assert_equal({ 'default_value' => nil }, merged)
+
+    merged = CommandReference.hash_merge(FILTERED_2_IOS_XR)
+    assert_equal({ 'set_value' => 'show inventory' }, merged)
+
+    merged = CommandReference.hash_merge(FILTERED_2_IOS_XR_CLI)
+    assert_equal({ 'set_value'   => 'show inventory',
+                   'get_command' => 'show inventory' }, merged)
   end
 end