import React, { Component } from 'react';
										import PropTypes from 'prop-types';

										class AttendeeCard extends Component {
											render() {
												let {id, firstName, lastName, dorgId, bio, presenter}
												= this.props

												return (
													<div
														className=`attendee ${presenter ? '_presenter' : ''}`>
														<h3>{`${firstName} ${lastName}`}</h3>
														<p className="-bio">{bio}</p>
													</div>
												)
											}
										}

										AttendeeCard.propTypes = {
											id: PropTypes.number,
											name: PropTypes.string,
											dorgId: PropTypes.string,
											bio: PropTypes.string,
											presenter: PropTypes.bool
										};

										export default AttendeeCard;
									

										import React from 'react';
										import {shallow, render, mount} from 'enzyme';
										import AttendeeCard from './AttendeeCard'

										test('Attendee Card renders', () => {
											let data = {
												id: 1,
												firstName: 'John',
												lastName: 'Smith',
												bio: 'bio...'
											}

											const wrapper = render(
												<AttendeeCard
													{...data}
												/>
											);

											expect(wrapper.find('h3').text())
												.toEqual('John Smith');
											expect(wrapper.find('.-bio').text())
												.toEqual('bio...');
										});
									

										export function getData() {
										  return function (dispatch, getState) {
											let endpointId = 'attendee'
											let endpoint = apiEndpoints[endpointId]
											dispatch(getDataPending())

											return axios({
											  url: endpoint.url,
											  method: endpoint.method,
											  timeout: endpoint.timeout
											})
											.then(res => {
											  var validate = ajv.compile(attendeeSchema)
											  var valid = validate(res.data)

											  if (!valid) {
												dispatch(getDataFail('Error fetching the data',
													validate.errors))
											  }
											  else {
												dispatch(getDataSuccess(res.data.attendee))
											  }
											})
											.catch(err => {
											  getDataFail('Error fetching the data')
											});
										  }
										}
									

										describe('Attendee actions', () => {
										  it('creates GET_DATA_SUCCESS', () => {
											let endpointId = 'attendee'
											let endpoint = apiEndpoints[endpointId]

											var mock = new MockAdapter(axios);
											const data = mockedObject;

											mock.onGet(endpoint.url).reply(200, data);

											const expectedActions = [
											  { type: 'GET_DATA_PENDING' },
											  { type: 'GET_DATA_SUCCESS', data: mockedObject}
											]
											const store = mockStore({})

											return store.dispatch(actions.getData()).then(() => {
											  expect(store.getActions()).toEqual(expectedActions)
											})
										  })
										});
									

										const default = {
											data: null,
											isFetching: false,
											isLoaded: false,
											error: null
										}

										export default function attendee(state = default, action) {
											switch(action.type) {
												case 'GET_DATA_SUCCESS' :
													return {
														...state,
														data: action.data,
														isLoaded: true,
														isFetching: false
													}
												case 'GET_DATA_PENDING' :
													return {
														...state,
														isFetching: true
													}
												...
												default:
													return state;
											}
										}
									

										import attendee from '../attendee'

										test('Attendee reducer test', () => {
											let initState = attendee(undefined, {type: null});

											let dataSuccess = {
												type: 'GET_DATA_SUCCESS',
												data: { test: "test" }
											};

											let attendeeSuccessUpdate = {
												isLoaded: true,
												isFetching: false
											};

											expect(attendee(initState, dataSuccess))
												.toEqual({
													...initialState,
													...attendeeSuccessUpdate,
													data: actionDataSuccess.data
												});
										});