Write a test for enum type using jest.

core/idl_types.h

@@ -27,5 +27,6 @@ struct IDLShort final : public IDLBaseHelper<int16_t> {};
 struct IDLString final : public IDLBaseHelper<std::string> {};
 // FIXME(Hwansung): should be generated automatically in another file.
 struct IDLOperationType final : public IDLBaseHelper<std::string> {};
+struct IDLTestEnum final : public IDLBaseHelper<std::string> {};
 
 #endif  // CORE_IDL_TYPES_H_

core/native_type_traits.h

@@ -199,4 +199,42 @@ struct NativeTypeTraits<IDLOperationType>
   }
 };
 
+template <>
+struct NativeTypeTraits<IDLTestEnum>
+    : public NativeTypeTraitsBase<IDLTestEnum> {
+  static std::string NativeValue(const Napi::Env& env,
+                                 const Napi::Value& js_value) {
+    if (!js_value.IsString()) {
+      Napi::TypeError::New(env, "It's an invalid string.")
+          .ThrowAsJavaScriptException();
+      return std::string();
+    }
+
+    std::string value = js_value.ToString().Utf8Value();
+    if (!IsValidValue(value)) {
+      Napi::TypeError::New(env, "it not matched with values of enum in idl.")
+          .ThrowAsJavaScriptException();
+      return std::string();
+    }
+
+    return js_value.ToString().Utf8Value();
+  }
+
+  static bool IsTypeEquals(const Napi::Value& js_value) {
+    if (js_value.IsString()) {
+      std::string value = js_value.ToString().Utf8Value();
+      return IsValidValue(value);
+    }
+    return false;
+  }
+
+  static bool IsValidValue(std::string value) {
+    if (value.compare("value1") == 0 || value.compare("value2") == 0 ||
+        value.compare("value3") == 0) {
+      return true;
+    }
+    return false;
+  }
+};
+
 #endif  // CORE_NATIVE_TYPE_TRAITS_H_

test/enum.test.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2017 The Bacardi 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 * as bindings from 'bindings';
+
+const bacardi = bindings('bacardi.node');
+
+test('Test for enum', async () => {
+  let test_interface = new bacardi.TestInterface();
+
+  test_interface.EnumMethod('value1');
+  expect(bacardi.TestInterface.getLastCallInfo()).toBe('EnumMethod(value1)');
+
+  test_interface.EnumMethod('value2');
+  expect(bacardi.TestInterface.getLastCallInfo()).toBe('EnumMethod(value2)');
+
+  test_interface.EnumMethod('value3');
+  expect(bacardi.TestInterface.getLastCallInfo()).toBe('EnumMethod(value3)');
+});
+
+test('Passing unexpected enum value should throw error', async () => {
+  let test_interface = new bacardi.TestInterface();
+
+  expect(() => {
+    test_interface.EnumMethod(1);
+  }).toThrowError();
+
+  expect(() => {
+    test_interface.EnumMethod('');
+  }).toThrowError();
+
+  expect(() => {
+    test_interface.EnumMethod('value');
+  }).toThrowError();
+
+});

test/test_interface.cc

@@ -64,3 +64,7 @@ double TestInterface::DoubleMethod(double number) {
 const std::string TestInterface::StringMethod(const std::string& string) {
   return string;
 }
+
+void TestInterface::EnumMethod(const std::string& string) {
+  last_call_info_ = "EnumMethod(" + string + ")";
+}

test/test_interface.h

@@ -37,6 +37,9 @@ class TestInterface {
   double DoubleMethod(double number);
   const std::string StringMethod(const std::string& string);
 
+  // Enum
+  void EnumMethod(const std::string& string);
+
  private:
   // FIXME(zino): Currently, we should set this variable in each methods. It's
   // not elegance way. We should find a way to get function name and signature

test/test_interface.idl

@@ -32,4 +32,13 @@ interface TestInterface {
   short shortMethod(short number);
   double doubleMethod(double number);
   string stringMethod(string string);
+
+  // enum
+  void EnumMethod(TestEnum enumValue);
 };
+
+enum TestEnum {
+  "value1",
+  "value2",
+  "value3"
+};