diff --git a/composite-aeson.cabal b/composite-aeson.cabal
--- a/composite-aeson.cabal
+++ b/composite-aeson.cabal
@@ -3,7 +3,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           composite-aeson
-version:        0.5.1.0
+version:        0.5.2.0
 synopsis:       JSON for Vinyl/Frames records
 description:    Integration between Aeson and Vinyl/Frames records allowing records to be easily converted to JSON using automatic derivation, explicit formats, or a mix of both.
 category:       Records
diff --git a/src/Composite/Aeson/Enum.hs b/src/Composite/Aeson/Enum.hs
--- a/src/Composite/Aeson/Enum.hs
+++ b/src/Composite/Aeson/Enum.hs
@@ -9,7 +9,7 @@
 import qualified Data.Map.Strict as M
 import Data.Text (Text, pack, unpack)
 import GHC.Generics (Generic(type Rep))
-import Generics.Deriving.ConNames (ConNames, conNames)
+import Generics.Deriving.ConNames (ConNames, conNameOf)
 import Generics.Deriving.Enum (Enum', genumDefault)
 
 -- |For some type @a@ which represents an enumeration (i.e. all nullary constructors) generate a 'JsonFormat' which maps that type to strings in JSON.
@@ -27,11 +27,11 @@
 -- > toJsonWithFormat myEnumFormat MyEnumFoo == Aeson.String "Foo"
 enumJsonFormat :: forall e a. (Show a, Ord a, Generic a, ConNames (Rep a), Enum' (Rep a)) => String -> JsonFormat e a
 enumJsonFormat prefix =
-  let names = map (pack . removePrefix) $ conNames (undefined :: a)
-      removePrefix s
+  let removePrefix s
         | Just suffix <- stripPrefix prefix s = suffix
         | otherwise                           = s
       values = genumDefault
+      names = map (pack . removePrefix . conNameOf) values
       lookupText  = flip HM.lookup . HM.fromList $ zip names values
       lookupValue = flip  M.lookup .  M.fromList $ zip values names
       expectedValues = "one of " ++ (intercalate ", " . map unpack $ names)
diff --git a/test/EnumSpec.hs b/test/EnumSpec.hs
--- a/test/EnumSpec.hs
+++ b/test/EnumSpec.hs
@@ -4,19 +4,35 @@
 import Data.Void (Void)
 import Data.Aeson (Value(String))
 import GHC.Generics (Generic)
-import Composite.Aeson.Base (JsonFormat, fromJsonWithFormat)
+import Composite.Aeson.Base (JsonFormat, fromJsonWithFormat, toJsonWithFormat)
 import Composite.Aeson.Enum (enumJsonFormat)
+import Composite.Aeson.Formats.Provided (listJsonFormat)
 import qualified Data.Aeson.BetterErrors as ABE
+import Data.Aeson.QQ (aesonQQ)
 import Test.Hspec (Spec, describe, it, shouldBe)
 
 data TestEnum = A | B deriving (Show, Eq, Ord, Generic)
 
+data LargerTestEnum = D | E | F | G deriving (Show, Eq, Ord, Generic)
+
 testEnumFormat :: JsonFormat Void TestEnum
 testEnumFormat = enumJsonFormat ""
 
+largerTestEnumFormat :: JsonFormat Void LargerTestEnum
+largerTestEnumFormat = enumJsonFormat ""
+
 enumSuite :: Spec
 enumSuite =
-  describe "enumJsonFormat" $
+  describe "enumJsonFormat" $ do
+    describe "when mapping ADTs with more than two branches" $ do
+      it "should encode each value correctly" $
+        toJsonWithFormat (listJsonFormat largerTestEnumFormat) [D,E,F,G]
+          `shouldBe` [aesonQQ|["D", "E", "F", "G"]|]
+
+      it "should decode each value correctly" $
+        ABE.parseValue (fromJsonWithFormat (listJsonFormat largerTestEnumFormat)) [aesonQQ|["D", "E", "F", "G"]|]
+          `shouldBe` Right [D,E,F,G]
+
     describe "when input value does not match any of enum constructors" $
       it "should return a parse error, not throw an exception" $
         ABE.parseValue (fromJsonWithFormat testEnumFormat) (String "C")