blob: 733652416eee6bd645a4af7e8cb447865846f825 [file] [log] [blame]
#
# Copyright 2016 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import json
import os
from unittest import TestCase
import time
from tests.itests.docutests.test_utils import run_command_to_completion_with_raw_stdout
from tests.utests.chameleon.protoc_plugins.test_utils import load_file, \
unindent, save_file
proto_to_yang_cmd='python -m grpc.tools.protoc -I{} ' \
'--plugin=protoc-gen-custom=/voltha/experiments' \
'/netconf/proto2yang/proto2yang.py --custom_out={} {}'
yang_validate_cmd="pyang -f tree --ietf {}"
TEMP_PATH="/tmp/proto2yang"
TEMP_INPUT_PROTO_FILE="test.proto"
TEMP_OUTPUT_YANG_FILE="ietf-test.yang"
TEMP_PROTO_PATH='{}/{}'.format(TEMP_PATH, TEMP_INPUT_PROTO_FILE)
TEMP_YANG_PATH='{}/{}'.format(TEMP_PATH, TEMP_OUTPUT_YANG_FILE)
class ProtoToYang(TestCase):
def setup(self):
if not os.path.exists(TEMP_PATH):
os.makedirs(TEMP_PATH)
def _compare_file(self, response, expected_response):
# compare two files and strip empty lines, blanks, etc
def _filter(x):
x.strip()
return x is not None
response = filter(_filter,response.split())
expected_response = filter(_filter,expected_response.split())
print response
print expected_response
self.assertEqual(set(response), set(expected_response))
def _gen_yang(self, proto):
try:
save_file(os.path.join(TEMP_PATH, TEMP_INPUT_PROTO_FILE), proto)
cmd = proto_to_yang_cmd.format(TEMP_PATH, TEMP_PATH, TEMP_PROTO_PATH
)
print 'running command: {}'.format(cmd)
response, err, rc = run_command_to_completion_with_raw_stdout(cmd)
self.assertEqual(rc, 0)
return load_file(TEMP_YANG_PATH)
except Exception as e:
print('Failure to generate yang file {}'.format(e))
def test_01_empty_proto(self):
print "Test_01_empty_proto_Start:------------------"
t0 = time.time()
proto = unindent("""
syntax = "proto3";
package test;
""")
expected_response = """
module ietf-test {
yang-version 1.1;
namespace "urn:ietf:params:xml:ns:yang:ietf-test";
prefix "voltha";
organization "CORD";
contact
" Any name";
description
"";
revision "2016-11-15" {
description "Initial revision.";
reference "reference";
}
}
"""
try:
yang = self._gen_yang(proto)
self._compare_file(yang, expected_response)
finally:
print "Test_01_empty_proto_End:------------------ took {} " \
"secs\n\n".format(time.time() - t0)
def test_02_empty_message_with_service(self):
print "Test_02_empty_message_with_service_Start:------------------"
t0 = time.time()
proto = unindent("""
syntax = "proto3";
package test;
message Null {}
service TestService {
rpc Get(Null) returns(Null);
}
""")
expected_response = """
module ietf-test {
yang-version 1.1;
namespace "urn:ietf:params:xml:ns:yang:ietf-test";
prefix "voltha";
organization "CORD";
contact
" Any name";
description
"";
revision "2016-11-15" {
description "Initial revision.";
reference "reference";
}
grouping Null {
description
"";
}
rpc TestService-Get {
description
"";
input {
uses Null;
}
output {
uses Null;
}
}
}
"""
try:
yang = self._gen_yang(proto)
self._compare_file(yang, expected_response)
finally:
print "Test_02_empty_message_with_service_End:------------------ took {} " \
"secs\n\n".format(time.time() - t0)
def test_03_simple_message_with_service(self):
print "Test__03_simple_message_with_service_Start:------------------"
t0 = time.time()
proto = unindent("""
syntax = "proto3";
package test;
// Simple Message
message Simple {
string str = 1; // a string attribute
int32 int = 2; // an int32 attribute
}
// Service to get things done
service TestService {
/* Get simple answer
*
* Returns the true answer to all of life's persistent questions.
*/
rpc Get(Simple) returns(Simple);
}
""")
expected_response = """
module ietf-test {
yang-version 1.1;
namespace "urn:ietf:params:xml:ns:yang:ietf-test";
prefix "voltha";
organization "CORD";
contact
" Any name";
description
"";
revision "2016-11-15" {
description "Initial revision.";
reference "reference";
}
grouping Simple {
description
"Simple Message";
leaf str {
type string;
description
"a string attribute";
}
leaf int {
type int32;
description
"an int32 attribute";
}
}
/* Service to get things done" */
rpc TestService-Get {
description
"Get simple answer
Returns the true answer to all of life's persistent questions.";
input {
uses Simple;
}
output {
uses Simple;
}
}
}
"""
try:
yang = self._gen_yang(proto)
self._compare_file(yang, expected_response)
finally:
print "Test_03_simple_message_with_service_End" \
":------------------ took {} secs\n\n".format(time.time() - t0)
def test_04_mix_types(self):
print "Test__04_mix_types_Start:------------------"
t0 = time.time()
proto = unindent("""
syntax = "proto3";
package experiment;
message AsyncEvent {
int32 seq = 1;
enum EventType {
BIG_BANG = 0; // just a big bang
SMALL_BANG = 1; // so small bang
NO_BANG = 2;
}
EventType type = 2;
string details = 3;
}
enum SimpleEnum {
APPLE = 0;
BANANA = 1;
ORANGE = 2;
}
message Packet {
int32 source = 1;
bytes content = 2;
message InnerPacket {
string url = 1;
string title = 2;
repeated string snippets = 3;
message InnerInnerPacket {
string input = 1;
string desc = 2;
}
repeated InnerInnerPacket inner_inner_packet = 4;
}
repeated InnerPacket inner_packets = 3;
}
message Echo {
string msg = 1;
float delay = 2;
}
message testMessage{
string test2 = 1;
int32 test3 = 2;
}
service ExperimentalService {
rpc GetEcho(Echo) returns(Echo);
// For server to send async stream to client
rpc ReceiveStreamedEvents(Packet)
returns(stream AsyncEvent);
// For server to send async packets to client
rpc ReceivePackets(Echo) returns(stream Packet);
// For client to send async packets to server
rpc SendPackets(stream Packet) returns(Echo);
}
""")
expected_response = """
module ietf-test {
yang-version 1.1;
namespace "urn:ietf:params:xml:ns:yang:ietf-test";
prefix "voltha";
organization "CORD";
contact
" Any name";
description
"";
revision "2016-11-15" {
description "Initial revision.";
reference "reference";
}
typedef SimpleEnum {
type enumeration {
enum APPLE {
description "";
}
enum BANANA {
description "";
}
enum ORANGE {
description "";
}
}
description
"";
}
grouping AsyncEvent {
description
"";
leaf seq {
type int32;
description
"";
}
leaf type {
type EventType;
description
"";
}
leaf details {
type string;
description
"";
}
typedef EventType {
type enumeration {
enum BIG_BANG {
description "";
}
enum SMALL_BANG {
description "";
}
enum NO_BANG {
description "";
}
}
description
"";
}
}
grouping Packet {
description
"";
leaf source {
type int32;
description
"";
}
leaf content {
type binary;
description
"";
}
list inner_packets {
key "url";
uses InnerPacket;
description
"";
}
grouping InnerPacket {
description
"";
leaf url {
type string;
description
"";
}
leaf title {
type string;
description
"";
}
list snippets {
key "snippets";
leaf snippets {
type string;
description
"";
}
description
"";
}
list inner_inner_packet {
key "input";
uses InnerInnerPacket;
description
"";
}
grouping InnerInnerPacket {
description
"";
leaf input {
type string;
description
"";
}
leaf desc {
type string;
description
"";
}
}
}
}
grouping Echo {
description
"";
leaf msg {
type string;
description
"";
}
leaf delay {
type decimal64 {
fraction-digits 5;
}
description
"";
}
}
container testMessage {
description
"";
leaf test2 {
type string;
description
"";
}
leaf test3 {
type int32;
description
"";
}
}
rpc ExperimentalService-GetEcho {
description
"";
input {
uses Echo;
}
output {
uses Echo;
}
}
rpc ExperimentalService-ReceiveStreamedEvents {
description
"For server to send async stream to client";
input {
uses Packet;
}
output {
uses AsyncEvent;
}
}
rpc ExperimentalService-ReceivePackets {
description
"For server to send async packets to client";
input {
uses Echo;
}
output {
uses Packet;
}
}
rpc ExperimentalService-SendPackets {
description
"For client to send async packets to server";
input {
uses Packet;
}
output {
uses Echo;
}
}
}
"""
try:
yang = self._gen_yang(proto)
self._compare_file(yang, expected_response)
finally:
print "Test_04_mix_types_End" \
":------------------ took {} secs\n\n".format(time.time() - t0)